This is an automated email from the git hooks/post-receive script. osallou pushed a commit to branch master in repository htsjdk.
commit bff963c958b60f79876f6b92c5ba48793e2a4749 Author: Olivier Sallou <olivier.sal...@debian.org> Date: Tue Jan 5 14:30:42 2016 +0100 skip more network tests --- debian/patches/13-skip_network_tests | 425 +++++++++++++++++++++++++++++++++++ 1 file changed, 425 insertions(+) diff --git a/debian/patches/13-skip_network_tests b/debian/patches/13-skip_network_tests index 1bda984..09dfa60 100644 --- a/debian/patches/13-skip_network_tests +++ b/debian/patches/13-skip_network_tests @@ -147,3 +147,428 @@ Last-Updated: 2015-01-06 @Test public void testSkip() throws IOException { +--- a/src/tests/java/htsjdk/samtools/sra/SRATest.java ++++ b/src/tests/java/htsjdk/samtools/sra/SRATest.java +@@ -43,422 +43,4 @@ + */ + public class SRATest { + +- @DataProvider(name = "testCounts") +- public Object[][] createDataForCounts() { +- return new Object[][] { +- {"SRR2096940", 10591, 498} +- }; +- } +- +- @Test(dataProvider = "testCounts") +- public void testCounts(String acc, int numberAlignments, int numberUnalignments) { +- if (!SRAAccession.isSupported()) return; +- +- SamReader reader = SamReaderFactory.make().validationStringency(ValidationStringency.SILENT).open( +- SamInputResource.of(new SRAAccession(acc)) +- ); +- +- final SAMRecordIterator samRecordIterator = reader.iterator(); +- +- checkAlignedUnalignedCountsByIterator(samRecordIterator, numberAlignments, numberUnalignments); +- } +- +- @DataProvider(name = "testCountsBySpan") +- public Object[][] createDataForCountsBySpan() { +- return new Object[][] { +- {"SRR2096940", Arrays.asList(new Chunk(0, 59128983), new Chunk(59128983, 59141089)), 10591, 498}, +- {"SRR2096940", Arrays.asList(new Chunk(0, 29128983), new Chunk(29128983, 59141089)), 10591, 498}, +- {"SRR2096940", Arrays.asList(new Chunk(0, 59134983), new Chunk(59134983, 59141089)), 10591, 498}, +- {"SRR2096940", Arrays.asList(new Chunk(0, 59130000)), 10591, 0}, +- {"SRR2096940", Arrays.asList(new Chunk(0, 59140889)), 10591, 298} +- }; +- } +- +- @Test(dataProvider = "testCountsBySpan") +- public void testCountsBySpan(String acc, List<Chunk> chunks, int numberAlignments, int numberUnalignments) { +- if (!SRAAccession.isSupported()) return; +- +- SamReader reader = SamReaderFactory.make().validationStringency(ValidationStringency.SILENT).open( +- SamInputResource.of(new SRAAccession(acc)) +- ); +- +- final SAMRecordIterator samRecordIterator = ((SamReader.Indexing) reader).iterator(new BAMFileSpan(chunks)); +- +- checkAlignedUnalignedCountsByIterator(samRecordIterator, numberAlignments, numberUnalignments); +- } +- +- @DataProvider(name = "testGroups") +- public Object[][] createDataForGroups() { +- return new Object[][] { +- {"SRR822962", new TreeSet<String>(Arrays.asList( +- "GS54389-FS3-L08", "GS57511-FS3-L08", "GS54387-FS3-L02", "GS54387-FS3-L01", +- "GS57510-FS3-L01", "GS57510-FS3-L03", "GS54389-FS3-L07", "GS54389-FS3-L05", +- "GS54389-FS3-L06", "GS57510-FS3-L02", "GS57510-FS3-L04", "GS54387-FS3-L03", +- "GS46253-FS3-L03")) +- }, +- {"SRR2096940", new HashSet<String>(Arrays.asList("SRR2096940"))} +- }; +- } +- +- @Test(dataProvider = "testGroups") +- public void testGroups(String acc, Set<String> groups) { +- if (!SRAAccession.isSupported()) return; +- +- SamReader reader = SamReaderFactory.make().validationStringency(ValidationStringency.SILENT).open( +- SamInputResource.of(new SRAAccession(acc)) +- ); +- +- final SAMRecordIterator samRecordIterator = reader.iterator(); +- +- SAMFileHeader header = reader.getFileHeader(); +- Set<String> headerGroups = new TreeSet<String>(); +- for (SAMReadGroupRecord group : header.getReadGroups()) { +- Assert.assertEquals(group.getReadGroupId(), group.getId()); +- headerGroups.add(group.getReadGroupId()); +- } +- +- Assert.assertEquals(groups, headerGroups); +- +- Set<String> foundGroups = new TreeSet<String>(); +- +- for (int i = 0; i < 10000; i++) { +- if (!samRecordIterator.hasNext()) { +- break; +- } +- SAMRecord record = samRecordIterator.next(); +- String groupName = (String)record.getAttribute("RG"); +- +- foundGroups.add(groupName); +- } +- +- // please note that some groups may be introduced after 10k records, which is not an error +- Assert.assertEquals(groups, foundGroups); +- } +- +- @DataProvider(name = "testReferences") +- public Object[][] createDataForReferences() { +- return new Object[][] { +- // primary alignment only +- {"SRR1063272", 1, +- Arrays.asList("supercont2.1", "supercont2.2", "supercont2.3", "supercont2.4", +- "supercont2.5", "supercont2.6", "supercont2.7", "supercont2.8", +- "supercont2.9", "supercont2.10", "supercont2.11", "supercont2.12", +- "supercont2.13", "supercont2.14"), +- Arrays.asList(2291499, 1621675, 1575141, 1084805, +- 1814975, 1422463, 1399503, 1398693, +- 1186808, 1059964, 1561994, 774062, +- 756744, 926563)}, +- }; +- } +- +- @Test(dataProvider = "testReferences") +- public void testReferences(String acc, int numberFirstReferenceFound, List<String> references, List<Integer> refLengths) { +- if (!SRAAccession.isSupported()) return; +- +- SamReader reader = SamReaderFactory.make().validationStringency(ValidationStringency.SILENT).open( +- SamInputResource.of(new SRAAccession(acc)) +- ); +- +- final SAMRecordIterator samRecordIterator = reader.iterator(); +- +- SAMFileHeader header = reader.getFileHeader(); +- Set<String> headerRefNames = new TreeSet<String>(); +- +- for (SAMSequenceRecord ref : header.getSequenceDictionary().getSequences()) { +- String refName = ref.getSequenceName(); +- +- int refIndex = references.indexOf(refName); +- Assert.assertTrue(refIndex != -1, "Unexpected reference: " + refName); +- +- Assert.assertEquals(refLengths.get(refIndex), (Integer) ref.getSequenceLength(), "Reference length is incorrect"); +- +- headerRefNames.add(refName); +- } +- +- Assert.assertEquals(new TreeSet<String>(references), headerRefNames); +- +- Set<String> foundRefNames = new TreeSet<String>(); +- for (int i = 0; i < 10000; i++) { +- if (!samRecordIterator.hasNext()) { +- break; +- } +- SAMRecord record = samRecordIterator.next(); +- +- if (record.getReferenceIndex().equals(SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX)) { +- continue; +- } +- +- String refName = record.getReferenceName(); +- Assert.assertNotNull(refName); +- +- foundRefNames.add(refName); +- } +- +- Assert.assertEquals(new TreeSet<String>(references.subList(0, numberFirstReferenceFound)), foundRefNames); +- } +- +- @DataProvider(name = "testRows") +- public Object[][] createDataForRowsTest() { +- return new Object[][] { +- // primary alignment only +- {"SRR1063272", 0, 99, "SRR1063272.R.1", +- "ACTCGACATTCTGCCTTCGACCTATCTTTCTCCTCTCCCAGTCATCGCCCAGTAGAATTACCAGGCAATGAACCAGGGCCTTCCATCCCAACGGCACAGCA", +- "@@CDDBDFFBFHFIEEFGIGGHIEHIGIGGFGEGAFDHIIIIIGGGDFHII;=BF@FEHGIEEH?AHHFHFFFFDC5'5=?CC?ADCD@AC??9BDDCDB<", +- 86, "101M", "supercont2.1", 60, true, false}, +- +- // small SRA archive +- {"SRR2096940", 1, 16, "SRR2096940.R.3", +- "GTGTGTCACCAGATAAGGAATCTGCCTAACAGGAGGTGTGGGTTAGACCCAATATCAGGAGACCAGGAAGGAGGAGGCCTAAGGATGGGGCTTTTCTGTCACCAATCCTGTCCCTAGTGGCCCCACTGTGGGGTGGAGGGGACAGATAAAAGTACCCAGAACCAGAG", +- "AAAABFFFFFFFGGGGGGGGIIIIIIIIIIIIIIIIIIIIIIIIIIIIII7IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIGGGGGFGFFDFFFFFC", +- 55627016, "167M", "CM000681.1", 42, false, false}, +- +- {"SRR2096940", 10591, 4, "SRR2096940.R.10592", +- "CTCTGGTTCTGGGTACTTTTATCTGTCCCCTCCACCCCACAGTGGCGAGCCAGATTCCTTATCTGGTGACACAC", +- "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII", +- -1, null, null, -1, false, false}, +- +- // primary and secondary alignments +- {"SRR833251", 81, 393, "SRR833251.R.51", +- "ATGCAAATCCGAATGGGCTATTTGTGGGTACTTGGGCAGGTAAGTAGCTGGCAATCTTGGTCGGTAAACCAATACCCAAGTTCACATAGGCACCATCGGGA", +- "CCCFFFFFHHHHHIJJJIJJJJJIIJJJGIJIJIIJIJJJDGIGIIJIJIHIJJJJJJGIGHIHEDFFFFDDEEEDDDDDCDEEDDDDDDDDDDDDDBBDB", +- 1787186, "38M63S", "gi|169794206|ref|NC_010410.1|", 11, true, true}, +- +- // local SRA file +- {"testdata/htsjdk/samtools/sra/test_archive.sra", 1, 99, "test_archive.R.2", +- "TGTCGATGCTGAAAGTGTCTGCGGTGAACCACTTCATGCACAGCGCACACTGCAGCTCCACTTCACCCAGCTGACGGCCGTTCTCATCGTCTCCAGAGCCCGTCTGAGCGTCCGCTGCTTCAGAACTGTCCCCGGCTGTATCCTGAAGAC", +- "BBAABBBFAFFFGGGGGGGGGGGGEEFHHHHGHHHHHFHHGHFDGGGGGHHGHHHHHHHHHHHHFHHHGHHHHHHGGGGGGGHGGHHHHHHHHHGHHHHHGGGGHGHHHGGGGGGGGGHHHHEHHHHHHHHHHGCGGGHHHHHHGBFFGF", +- 2811570, "150M", "NC_007121.5", 60, true, false} +- }; +- } +- +- @Test(dataProvider = "testRows") +- public void testRows(String acc, int recordIndex, int flags, String readName, String bases, String quals, int refStart, String cigar, +- String refName, int mapQ, boolean hasMate, boolean isSecondaryAlignment) { +- if (!SRAAccession.isSupported()) return; +- +- SAMRecord record = getRecordByIndex(acc, recordIndex, false); +- +- checkSAMRecord(record, flags, readName, bases, quals, refStart, cigar, refName, mapQ, hasMate, isSecondaryAlignment); +- } +- +- @Test(dataProvider = "testRows") +- public void testRowsAfterIteratorDetach(String acc, int recordIndex, int flags, String readName, String bases, String quals, +- int refStart, String cigar, String refName, int mapQ, boolean hasMate, +- boolean isSecondaryAlignment) { +- if (!SRAAccession.isSupported()) return; +- +- SAMRecord record = getRecordByIndex(acc, recordIndex, true); +- +- checkSAMRecord(record, flags, readName, bases, quals, refStart, cigar, refName, mapQ, hasMate, isSecondaryAlignment); +- } +- +- @Test(dataProvider = "testRows") +- public void testRowsOverrideValues(String acc, int recordIndex, int flags, String readName, String bases, String quals, +- int refStart, String cigar, String refName, int mapQ, boolean hasMate, +- boolean isSecondaryAlignment) { +- if (!SRAAccession.isSupported()) return; +- +- SAMRecord record = getRecordByIndex(acc, recordIndex, true); +- SAMFileHeader header = record.getHeader(); +- +- +- record.setFlags(0); +- record.setReadUnmappedFlag(refStart == -1); +- record.setReadBases("C".getBytes()); +- record.setBaseQualities(SAMUtils.fastqToPhred("A")); +- if (refStart == -1) { +- checkSAMRecord(record, 4, readName, "C", "A", refStart, "1M", refName, mapQ, false, false); +- } else { +- int sequenceIndex = header.getSequenceIndex(refName); +- Assert.assertFalse(sequenceIndex == -1); +- +- if (sequenceIndex == 0) { +- if (header.getSequenceDictionary().getSequences().size() > 1) { +- sequenceIndex++; +- } +- } else { +- sequenceIndex--; +- } +- +- refName = header.getSequence(sequenceIndex).getSequenceName(); +- +- record.setAlignmentStart(refStart - 100); +- record.setCigarString("1M"); +- record.setMappingQuality(mapQ - 1); +- record.setReferenceIndex(sequenceIndex); +- +- checkSAMRecord(record, 0, readName, "C", "A", refStart - 100, "1M", refName, mapQ - 1, false, false); +- } +- } +- +- @Test(dataProvider = "testRows") +- public void testRowsBySpan(String acc, int recordIndex, int flags, String readName, String bases, String quals, +- int refStart, String cigar, String refName, int mapQ, boolean hasMate, +- boolean isSecondaryAlignment) { +- if (!SRAAccession.isSupported()) return; +- +- SamReader reader = SamReaderFactory.make().validationStringency(ValidationStringency.SILENT).open( +- SamInputResource.of(new SRAAccession(acc)) +- ); +- +- SAMFileHeader header = reader.getFileHeader(); +- +- Chunk chunk; +- if (refStart != -1) { +- long refOffset = 0; +- int refIndex = header.getSequenceDictionary().getSequence(refName).getSequenceIndex(); +- for (SAMSequenceRecord sequenceRecord : header.getSequenceDictionary().getSequences()) { +- if (sequenceRecord.getSequenceIndex() < refIndex) { +- refOffset += sequenceRecord.getSequenceLength(); +- } +- } +- +- chunk = new Chunk(refOffset + refStart - 1, refOffset + refStart); +- } else { +- long totalRefLength = header.getSequenceDictionary().getReferenceLength(); +- long totalRecordRange = ((BAMFileSpan)reader.indexing().getFilePointerSpanningReads()).toCoordinateArray()[1]; +- chunk = new Chunk(totalRefLength, totalRecordRange); +- } +- +- final SAMRecordIterator samRecordIterator = ((SamReader.Indexing) reader).iterator(new BAMFileSpan(chunk)); +- +- SAMRecord record = null; +- while (samRecordIterator.hasNext()) { +- SAMRecord currentRecord = samRecordIterator.next(); +- if (currentRecord.getReadName().equals(readName)) { +- record = currentRecord; +- break; +- } +- } +- +- checkSAMRecord(record, flags, readName, bases, quals, refStart, cigar, refName, mapQ, hasMate, isSecondaryAlignment); +- } +- +- @Test(dataProvider = "testRows") +- public void testRowsByIndex(String acc, int recordIndex, int flags, String readName, String bases, String quals, +- int refStart, String cigar, String refName, int mapQ, boolean hasMate, +- boolean isSecondaryAlignment) { +- if (!SRAAccession.isSupported()) return; +- +- SamReader reader = SamReaderFactory.make().validationStringency(ValidationStringency.SILENT).open( +- SamInputResource.of(new SRAAccession(acc)) +- ); +- +- Assert.assertTrue(reader.hasIndex()); +- Assert.assertTrue(reader.indexing().hasBrowseableIndex()); +- +- SAMFileHeader header = reader.getFileHeader(); +- BrowseableBAMIndex index = reader.indexing().getBrowseableIndex(); +- +- BAMFileSpan span; +- if (refStart != -1) { +- int refIndex = header.getSequenceDictionary().getSequence(refName).getSequenceIndex(); +- span = index.getSpanOverlapping(refIndex, refStart, refStart + 1); +- } else { +- long chunkStart = index.getStartOfLastLinearBin(); +- long totalRecordRange = ((BAMFileSpan) reader.indexing().getFilePointerSpanningReads()).toCoordinateArray()[1]; +- span = new BAMFileSpan(new Chunk(chunkStart, totalRecordRange)); +- } +- +- final SAMRecordIterator samRecordIterator = ((SamReader.Indexing) reader).iterator(span); +- +- SAMRecord record = null; +- while (samRecordIterator.hasNext()) { +- SAMRecord currentRecord = samRecordIterator.next(); +- if (refStart != -1 && currentRecord.getAlignmentStart() + currentRecord.getReadLength() < refStart) { +- continue; +- } +- +- if (currentRecord.getReadName().equals(readName)) { +- record = currentRecord; +- break; +- } +- } +- +- checkSAMRecord(record, flags, readName, bases, quals, refStart, cigar, refName, mapQ, hasMate, isSecondaryAlignment); +- } +- +- private SAMRecord getRecordByIndex(String acc, int recordIndex, boolean detach) { +- SamReader reader = SamReaderFactory.make().validationStringency(ValidationStringency.SILENT).open( +- SamInputResource.of(new SRAAccession(acc)) +- ); +- +- final SAMRecordIterator samRecordIterator = reader.iterator(); +- +- while (recordIndex != 0) { +- Assert.assertTrue(samRecordIterator.hasNext(), "Record set is too small"); +- +- samRecordIterator.next(); +- recordIndex--; +- } +- Assert.assertTrue(samRecordIterator.hasNext(), "Record set is too small"); +- +- SAMRecord record = samRecordIterator.next(); +- +- if (detach) { +- samRecordIterator.next(); +- } +- +- return record; +- } +- +- private void checkSAMRecord(SAMRecord record, int flags, String readName, String bases, String quals, +- int refStart, String cigar, String refName, int mapQ, boolean hasMate, +- boolean isSecondaryAlignment) { +- +- Assert.assertNotNull(record, "Record with read id: " + readName + " was not found by span created from index"); +- +- List<SAMValidationError> validationErrors = record.isValid(); +- Assert.assertNull(validationErrors, "SRA Lazy record is invalid. List of errors: " + +- (validationErrors != null ? validationErrors.toString() : "")); +- +- Assert.assertEquals(new String(record.getReadBases()), bases); +- Assert.assertEquals(record.getBaseQualityString(), quals); +- Assert.assertEquals(record.getReadPairedFlag(), hasMate); +- Assert.assertEquals(record.getFlags(), flags); +- Assert.assertEquals(record.getNotPrimaryAlignmentFlag(), isSecondaryAlignment); +- if (refStart == -1) { +- Assert.assertEquals(record.getReadUnmappedFlag(), true); +- Assert.assertEquals(record.getAlignmentStart(), 0); +- Assert.assertEquals(record.getCigarString(), "*"); +- Assert.assertEquals(record.getReferenceName(), "*"); +- Assert.assertEquals(record.getMappingQuality(), 0); +- } else { +- Assert.assertEquals(record.getReadUnmappedFlag(), false); +- Assert.assertEquals(record.getAlignmentStart(), refStart); +- Assert.assertEquals(record.getCigarString(), cigar); +- Assert.assertEquals(record.getReferenceName(), refName); +- Assert.assertEquals(record.getMappingQuality(), mapQ); +- } +- } +- +- private void checkAlignedUnalignedCountsByIterator(SAMRecordIterator samRecordIterator, +- int numberAlignments, int numberUnalignments) { +- int countAlignments = 0, countUnalignments = 0; +- while (true) { +- boolean hasRecord = samRecordIterator.hasNext(); +- SAMRecord record = null; +- try { +- record = samRecordIterator.next(); +- Assert.assertTrue(hasRecord); // exception is not thrown if we came to this point +- } catch (NoSuchElementException e) { +- Assert.assertFalse(hasRecord); +- } +- +- Assert.assertEquals(hasRecord, record != null); +- +- if (record == null) { +- break; +- } +- +- if (record.getReadUnmappedFlag()) { +- countUnalignments++; +- } else { +- countAlignments++; +- } +- } +- +- Assert.assertEquals(numberAlignments, countAlignments); +- Assert.assertEquals(numberUnalignments, countUnalignments); +- } + } -- Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-med/htsjdk.git _______________________________________________ debian-med-commit mailing list debian-med-commit@lists.alioth.debian.org http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/debian-med-commit