def test_append_without_qual(self):
seq_pair = stuff.get_mini_ref_seqs()[0]
self.w.append(seq_pair[0], seq_pair[1], None, rapi.QENC_SANGER)
self.assertEquals(1, len(self.w))
read1 = self.w.get_read(0, 0)
self.assertEquals(seq_pair[1], read1.seq)
self.assertIsNone(read1.qual)
def test_n_fragments(self):
seq_pair = stuff.get_mini_ref_seqs()[0]
self.assertEquals(0, self.w.n_fragments)
# insert one read
self.w.append(seq_pair[0], seq_pair[1], seq_pair[2], rapi.QENC_SANGER)
self.assertEquals(0, self.w.n_fragments)
self.w.append(seq_pair[0], seq_pair[3], seq_pair[4], rapi.QENC_SANGER)
self.assertEquals(1, self.w.n_fragments)
def test_clear(self):
seq_pair = stuff.get_mini_ref_seqs()[0]
self.w.append(seq_pair[0], seq_pair[1], seq_pair[2], rapi.QENC_SANGER)
self.assertEquals(1, len(self.w))
self.w.clear()
# after clear, the length should be back to zero, but the capacity should be unaffected.
self.assertEquals(0, len(self.w))
self.assertGreaterEqual(self.w.capacity, 1)
def test_append_illumina(self):
seq_pair = stuff.get_mini_ref_seqs()[0]
# convert the base qualities from sanger to illumina encoding
# (subtract sanger offset and add illumina offset)
illumina_qualities = ''.join([ chr(ord(c) - 33 + 64) for c in seq_pair[2] ])
self.w.append(seq_pair[0], seq_pair[1], illumina_qualities, rapi.QENC_ILLUMINA)
read1 = self.w.get_read(0, 0)
# Internally base qualities should be converted to sanger format
self.assertEquals(seq_pair[2], read1.qual)
def test_iteration_completeness(self):
# empty batch
self.assertEquals(0, sum(1 for frag in self.w))
# now put some sequences into it
seqs = stuff.get_mini_ref_seqs()
for pair in seqs:
self.w.append(pair[0], pair[1], pair[2], rapi.QENC_SANGER)
self.w.append(pair[0], pair[3], pair[4], rapi.QENC_SANGER)
# test whether we iterate over all the fragments
self.assertEquals(len(seqs), sum(1 for frag in self.w))
def test_iteration_completeness_single_end(self):
seqs = stuff.get_mini_ref_seqs()
batch = rapi.read_batch(1)
for pair in seqs:
batch.append(pair[0], pair[1], pair[2], rapi.QENC_SANGER)
batch.append(pair[0], pair[3], pair[4], rapi.QENC_SANGER)
# test whether we iterate over all the fragments
self.assertEquals(2 * len(seqs), sum(1 for frag in batch))
it = iter(batch)
fragment = next(it)
self.assertEquals(1, len(fragment))
def test_append_baseq_out_of_range(self):
seq_pair = stuff.get_mini_ref_seqs()[0]
new_q = chr(32)*len(seq_pair[1]) # sanger encoding goes down to 33
self.assertRaises(ValueError, self.w.append, seq_pair[0], seq_pair[1], new_q, rapi.QENC_SANGER)
new_q = chr(127)*len(seq_pair[1]) # and up to 126
self.assertRaises(ValueError, self.w.append, seq_pair[0], seq_pair[1], new_q, rapi.QENC_SANGER)
new_q = chr(63)*len(seq_pair[1]) # illumina encoding goes down to 64
self.assertRaises(ValueError, self.w.append, seq_pair[0], seq_pair[1], new_q, rapi.QENC_ILLUMINA)
def test_append_one(self):
seq_pair = stuff.get_mini_ref_seqs()[0]
# insert one read
self.w.append(seq_pair[0], seq_pair[1], seq_pair[2], rapi.QENC_SANGER)
self.assertEquals(1, len(self.w))
read1 = self.w.get_read(0, 0)
self.assertEquals(seq_pair[0], read1.id)
self.assertEquals(seq_pair[1], read1.seq)
self.assertEquals(seq_pair[2], read1.qual)
self.assertEquals(len(seq_pair[1]), len(read1))
self.assertEquals(0, self.w.n_fragments)
def setUp(self):
self.opts = rapi.opts()
self.opts.share_ref_mem = False # for Travis
rapi.init(self.opts)
self.ref = rapi.ref(stuff.MiniRef)
aligner = rapi.aligner(self.opts)
self.batch = rapi.read_batch(2)
reads = stuff.get_mini_ref_seqs()
for row in reads:
self.batch.append(row[0], row[1], row[2], rapi.QENC_SANGER)
self.batch.append(row[0], row[3], row[4], rapi.QENC_SANGER)
aligner.align_reads(self.ref, self.batch)
def test_iteration_values(self):
seqs = stuff.get_mini_ref_seqs()[0:2]
for pair in seqs:
self.w.append(pair[0], pair[1], pair[2], rapi.QENC_SANGER)
self.w.append(pair[0], pair[3], pair[4], rapi.QENC_SANGER)
for idx, fragment in enumerate(self.w):
self.assertEquals(2, len(fragment))
self.assertEquals(seqs[idx][0], fragment[0].id)
self.assertEquals(seqs[idx][1], fragment[0].seq)
self.assertEquals(seqs[idx][0], fragment[1].id)
self.assertEquals(seqs[idx][3], fragment[1].seq)
def test_get_read_out_of_bounds(self):
self.assertEqual(0, len(self.w))
self.assertRaises(IndexError, self.w.get_read, 0, 0)
self.assertRaises(IndexError, self.w.get_read, -1, 0)
self.assertRaises(IndexError, self.w.get_read, -1, -1)
# now load a sequence and ensure we get exceptions if we access beyond the limits
seq_pair = stuff.get_mini_ref_seqs()[0]
self.w.append(seq_pair[0], seq_pair[1], seq_pair[2], rapi.QENC_SANGER)
self.assertIsNotNone(self.w.get_read(0, 0))
self.assertRaises(IndexError, self.w.get_read, 0, 1)
self.assertRaises(IndexError, self.w.get_read, 1, 0)
self.assertRaises(IndexError, self.w.get_read, 1, 1)
self.assertRaises(TypeError, self.w.get_read, None, 0)
self.assertRaises(TypeError, self.w.get_read, 0, None)
