@Test public void testWholeIndelReadInIsolation() { final int firstLocus = 44367789; // create a test version of the Reads object ReadProperties readAttributes = createTestReadProperties(); SAMRecord indelOnlyRead = ArtificialSAMUtils.createArtificialRead(header, "indelOnly", 0, firstLocus, 76); indelOnlyRead.setReadBases(Utils.dupBytes((byte) 'A', 76)); indelOnlyRead.setBaseQualities(Utils.dupBytes((byte) '@', 76)); indelOnlyRead.setCigarString("76I"); List<SAMRecord> reads = Arrays.asList(indelOnlyRead); // create the iterator by state with the fake reads and fake records li = makeLTBS(reads, readAttributes); // Traditionally, reads that end with indels bleed into the pileup at the following locus. // Verify that the next pileup contains this read // and considers it to be an indel-containing read. Assert.assertTrue( li.hasNext(), "Should have found a whole-indel read in the normal base pileup without extended events enabled"); AlignmentContext alignmentContext = li.next(); Assert.assertEquals( alignmentContext.getLocation().getStart(), firstLocus, "Base pileup is at incorrect location."); ReadBackedPileup basePileup = alignmentContext.getBasePileup(); Assert.assertEquals(basePileup.getReads().size(), 1, "Pileup is of incorrect size"); Assert.assertSame(basePileup.getReads().get(0), indelOnlyRead, "Read in pileup is incorrect"); }
@Test(dataProvider = "LIBSTest") public void testLIBS(LIBSTest params) { final int locus = 44367788; SAMRecord read = ArtificialSAMUtils.createArtificialRead(header, "read", 0, locus, params.readLength); read.setReadBases(Utils.dupBytes((byte) 'A', params.readLength)); read.setBaseQualities(Utils.dupBytes((byte) '@', params.readLength)); read.setCigarString(params.cigar); // create the iterator by state with the fake reads and fake records li = makeLTBS(Arrays.asList(read), createTestReadProperties()); final LIBS_position tester = new LIBS_position(read); while (li.hasNext()) { AlignmentContext alignmentContext = li.next(); ReadBackedPileup p = alignmentContext.getBasePileup(); Assert.assertTrue(p.getNumberOfElements() == 1); PileupElement pe = p.iterator().next(); tester.stepForwardOnGenome(); Assert.assertEquals(pe.isBeforeDeletedBase(), tester.isBeforeDeletedBase); Assert.assertEquals(pe.isBeforeDeletionStart(), tester.isBeforeDeletionStart); Assert.assertEquals(pe.isAfterDeletedBase(), tester.isAfterDeletedBase); Assert.assertEquals(pe.isAfterDeletionEnd(), tester.isAfterDeletionEnd); Assert.assertEquals(pe.isBeforeInsertion(), tester.isBeforeInsertion); Assert.assertEquals(pe.isAfterInsertion(), tester.isAfterInsertion); Assert.assertEquals(pe.isNextToSoftClip(), tester.isNextToSoftClip); Assert.assertEquals(pe.getOffset(), tester.getCurrentReadOffset()); } }
@Test public void testIndelsInRegularPileup() { final byte[] bases = new byte[] {'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A'}; final byte[] indelBases = new byte[] {'A', 'A', 'A', 'A', 'C', 'T', 'A', 'A', 'A', 'A', 'A', 'A'}; // create a test version of the Reads object ReadProperties readAttributes = createTestReadProperties(); SAMRecord before = ArtificialSAMUtils.createArtificialRead(header, "before", 0, 1, 10); before.setReadBases(bases); before.setBaseQualities(new byte[] {20, 20, 20, 20, 20, 20, 20, 20, 20, 20}); before.setCigarString("10M"); SAMRecord during = ArtificialSAMUtils.createArtificialRead(header, "during", 0, 2, 10); during.setReadBases(indelBases); during.setBaseQualities(new byte[] {20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20}); during.setCigarString("4M2I6M"); SAMRecord after = ArtificialSAMUtils.createArtificialRead(header, "after", 0, 3, 10); after.setReadBases(bases); after.setBaseQualities(new byte[] {20, 20, 20, 20, 20, 20, 20, 20, 20, 20}); after.setCigarString("10M"); List<SAMRecord> reads = Arrays.asList(before, during, after); // create the iterator by state with the fake reads and fake records li = makeLTBS(reads, readAttributes); boolean foundIndel = false; while (li.hasNext()) { AlignmentContext context = li.next(); ReadBackedPileup pileup = context.getBasePileup().getBaseFilteredPileup(10); for (PileupElement p : pileup) { if (p.isBeforeInsertion()) { foundIndel = true; Assert.assertEquals(p.getEventLength(), 2, "Wrong event length"); Assert.assertEquals(p.getEventBases(), "CT", "Inserted bases are incorrect"); break; } } } Assert.assertTrue(foundIndel, "Indel in pileup not found"); }
/** * Test to make sure that reads supporting only an indel (example cigar string: 76I) are * represented properly */ @Test public void testWholeIndelReadRepresentedTest() { final int firstLocus = 44367788, secondLocus = firstLocus + 1; SAMRecord read1 = ArtificialSAMUtils.createArtificialRead(header, "read1", 0, secondLocus, 1); read1.setReadBases(Utils.dupBytes((byte) 'A', 1)); read1.setBaseQualities(Utils.dupBytes((byte) '@', 1)); read1.setCigarString("1I"); List<SAMRecord> reads = Arrays.asList(read1); // create the iterator by state with the fake reads and fake records li = makeLTBS(reads, createTestReadProperties()); while (li.hasNext()) { AlignmentContext alignmentContext = li.next(); ReadBackedPileup p = alignmentContext.getBasePileup(); Assert.assertTrue(p.getNumberOfElements() == 1); PileupElement pe = p.iterator().next(); Assert.assertTrue(pe.isBeforeInsertion()); Assert.assertFalse(pe.isAfterInsertion()); Assert.assertEquals(pe.getEventBases(), "A"); } SAMRecord read2 = ArtificialSAMUtils.createArtificialRead(header, "read2", 0, secondLocus, 10); read2.setReadBases(Utils.dupBytes((byte) 'A', 10)); read2.setBaseQualities(Utils.dupBytes((byte) '@', 10)); read2.setCigarString("10I"); reads = Arrays.asList(read2); // create the iterator by state with the fake reads and fake records li = makeLTBS(reads, createTestReadProperties()); while (li.hasNext()) { AlignmentContext alignmentContext = li.next(); ReadBackedPileup p = alignmentContext.getBasePileup(); Assert.assertTrue(p.getNumberOfElements() == 1); PileupElement pe = p.iterator().next(); Assert.assertTrue(pe.isBeforeInsertion()); Assert.assertFalse(pe.isAfterInsertion()); Assert.assertEquals(pe.getEventBases(), "AAAAAAAAAA"); } }
@Test public void testXandEQOperators() { final byte[] bases1 = new byte[] {'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A'}; final byte[] bases2 = new byte[] {'A', 'A', 'A', 'C', 'A', 'A', 'A', 'A', 'A', 'C'}; // create a test version of the Reads object ReadProperties readAttributes = createTestReadProperties(); SAMRecord r1 = ArtificialSAMUtils.createArtificialRead(header, "r1", 0, 1, 10); r1.setReadBases(bases1); r1.setBaseQualities(new byte[] {20, 20, 20, 20, 20, 20, 20, 20, 20, 20}); r1.setCigarString("10M"); SAMRecord r2 = ArtificialSAMUtils.createArtificialRead(header, "r2", 0, 1, 10); r2.setReadBases(bases2); r2.setBaseQualities(new byte[] {20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20}); r2.setCigarString("3=1X5=1X"); SAMRecord r3 = ArtificialSAMUtils.createArtificialRead(header, "r3", 0, 1, 10); r3.setReadBases(bases2); r3.setBaseQualities(new byte[] {20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20}); r3.setCigarString("3=1X5M1X"); SAMRecord r4 = ArtificialSAMUtils.createArtificialRead(header, "r4", 0, 1, 10); r4.setReadBases(bases2); r4.setBaseQualities(new byte[] {20, 20, 20, 20, 20, 20, 20, 20, 20, 20}); r4.setCigarString("10M"); List<SAMRecord> reads = Arrays.asList(r1, r2, r3, r4); // create the iterator by state with the fake reads and fake records li = makeLTBS(reads, readAttributes); while (li.hasNext()) { AlignmentContext context = li.next(); ReadBackedPileup pileup = context.getBasePileup(); Assert.assertEquals(pileup.depthOfCoverage(), 4); } }
@BeforeClass private void init() throws IOException { reference = new CachingIndexedFastaSequenceFile(new File(b37KGReference)); dictionary = reference.getSequenceDictionary(); genomeLocParser = new GenomeLocParser(dictionary); header = ArtificialSAMUtils.createDefaultReadGroup(new SAMFileHeader(), "test", "test"); header.setSequenceDictionary(dictionary); header.setSortOrder(SAMFileHeader.SortOrder.coordinate); readGroup = new GATKSAMReadGroupRecord(header.getReadGroup("test")); final List<GATKSAMRecord> reads = new ArrayList<>(); for (final String contig : contigs) { for (int i = 1; i <= numReadsPerContig; i++) { reads.add(buildSAMRecord("read" + contig + "_" + i, contig, i)); } } createBAM(reads); }
@BeforeClass public void beforeClass() { header = ArtificialSAMUtils.createArtificialSamHeader(1, 1, 1000); genomeLocParser = new GenomeLocParser(header.getSequenceDictionary()); }
/** * Test to make sure that reads supporting only an indel (example cigar string: 76I) do not * negatively influence the ordering of the pileup. */ @Test public void testWholeIndelRead() { final int firstLocus = 44367788, secondLocus = firstLocus + 1; SAMRecord leadingRead = ArtificialSAMUtils.createArtificialRead(header, "leading", 0, firstLocus, 76); leadingRead.setReadBases(Utils.dupBytes((byte) 'A', 76)); leadingRead.setBaseQualities(Utils.dupBytes((byte) '@', 76)); leadingRead.setCigarString("1M75I"); SAMRecord indelOnlyRead = ArtificialSAMUtils.createArtificialRead(header, "indelOnly", 0, secondLocus, 76); indelOnlyRead.setReadBases(Utils.dupBytes((byte) 'A', 76)); indelOnlyRead.setBaseQualities(Utils.dupBytes((byte) '@', 76)); indelOnlyRead.setCigarString("76I"); SAMRecord fullMatchAfterIndel = ArtificialSAMUtils.createArtificialRead(header, "fullMatch", 0, secondLocus, 76); fullMatchAfterIndel.setReadBases(Utils.dupBytes((byte) 'A', 76)); fullMatchAfterIndel.setBaseQualities(Utils.dupBytes((byte) '@', 76)); fullMatchAfterIndel.setCigarString("75I1M"); List<SAMRecord> reads = Arrays.asList(leadingRead, indelOnlyRead, fullMatchAfterIndel); // create the iterator by state with the fake reads and fake records li = makeLTBS(reads, createTestReadProperties()); int currentLocus = firstLocus; int numAlignmentContextsFound = 0; while (li.hasNext()) { AlignmentContext alignmentContext = li.next(); Assert.assertEquals( alignmentContext.getLocation().getStart(), currentLocus, "Current locus returned by alignment context is incorrect"); if (currentLocus == firstLocus) { List<GATKSAMRecord> readsAtLocus = alignmentContext.getBasePileup().getReads(); Assert.assertEquals( readsAtLocus.size(), 1, "Wrong number of reads at locus " + currentLocus); Assert.assertSame( readsAtLocus.get(0), leadingRead, "leadingRead absent from pileup at locus " + currentLocus); } else if (currentLocus == secondLocus) { List<GATKSAMRecord> readsAtLocus = alignmentContext.getBasePileup().getReads(); Assert.assertEquals( readsAtLocus.size(), 2, "Wrong number of reads at locus " + currentLocus); Assert.assertSame( readsAtLocus.get(0), indelOnlyRead, "indelOnlyRead absent from pileup at locus " + currentLocus); Assert.assertSame( readsAtLocus.get(1), fullMatchAfterIndel, "fullMatchAfterIndel absent from pileup at locus " + currentLocus); } currentLocus++; numAlignmentContextsFound++; } Assert.assertEquals( numAlignmentContextsFound, 2, "Found incorrect number of alignment contexts"); }
/** * @author aaron * @version 1.0 * <p>Class GenomeLocSetTest * <p>This tests the functions of the GenomeLocSet */ public class GenomeLocSortedSetUnitTest extends BaseTest { private GenomeLocSortedSet mSortedSet = null; private SAMFileHeader header = ArtificialSAMUtils.createArtificialSamHeader( NUMBER_OF_CHROMOSOMES, STARTING_CHROMOSOME, CHROMOSOME_SIZE); private static final int NUMBER_OF_CHROMOSOMES = 5; private static final int STARTING_CHROMOSOME = 1; private static final int CHROMOSOME_SIZE = 1000; private GenomeLocParser genomeLocParser; private String contigOneName; @BeforeClass public void setup() { genomeLocParser = new GenomeLocParser(header.getSequenceDictionary()); contigOneName = header.getSequenceDictionary().getSequence(1).getSequenceName(); } @BeforeMethod public void initializeSortedSet() { mSortedSet = new GenomeLocSortedSet(genomeLocParser); } @Test public void testAdd() { GenomeLoc g = genomeLocParser.createGenomeLoc(contigOneName, 0, 0); assertTrue(mSortedSet.size() == 0); mSortedSet.add(g); assertTrue(mSortedSet.size() == 1); } @Test public void testRemove() { assertTrue(mSortedSet.size() == 0); GenomeLoc g = genomeLocParser.createGenomeLoc(contigOneName, 0, 0); mSortedSet.add(g); assertTrue(mSortedSet.size() == 1); mSortedSet.remove(g); assertTrue(mSortedSet.size() == 0); } @Test public void addRegion() { assertTrue(mSortedSet.size() == 0); GenomeLoc g = genomeLocParser.createGenomeLoc(contigOneName, 1, 50); mSortedSet.add(g); GenomeLoc f = genomeLocParser.createGenomeLoc(contigOneName, 30, 80); mSortedSet.addRegion(f); assertTrue(mSortedSet.size() == 1); } @Test public void addRegionsOutOfOrder() { final String contigTwoName = header.getSequenceDictionary().getSequence(2).getSequenceName(); assertTrue(mSortedSet.size() == 0); GenomeLoc g = genomeLocParser.createGenomeLoc(contigTwoName, 1, 50); mSortedSet.add(g); GenomeLoc f = genomeLocParser.createGenomeLoc(contigOneName, 30, 80); mSortedSet.addRegion(f); assertTrue(mSortedSet.size() == 2); assertTrue(mSortedSet.toList().get(0).getContig().equals(contigOneName)); assertTrue(mSortedSet.toList().get(1).getContig().equals(contigTwoName)); } @Test(expectedExceptions = IllegalArgumentException.class) public void addThrowsException() { assertTrue(mSortedSet.size() == 0); GenomeLoc g = genomeLocParser.createGenomeLoc(contigOneName, 1, 50); mSortedSet.add(g); GenomeLoc f = genomeLocParser.createGenomeLoc(contigOneName, 30, 80); mSortedSet.add(f); } @Test(expectedExceptions = IllegalArgumentException.class) public void testAddDuplicate() { assertTrue(mSortedSet.size() == 0); GenomeLoc g = genomeLocParser.createGenomeLoc(contigOneName, 0, 0); mSortedSet.add(g); assertTrue(mSortedSet.size() == 1); mSortedSet.add(g); } @Test public void mergingOverlappingBelow() { GenomeLoc g = genomeLocParser.createGenomeLoc(contigOneName, 0, 50); GenomeLoc e = genomeLocParser.createGenomeLoc(contigOneName, 49, 100); assertTrue(mSortedSet.size() == 0); mSortedSet.add(g); assertTrue(mSortedSet.size() == 1); mSortedSet.addRegion(e); assertTrue(mSortedSet.size() == 1); Iterator<GenomeLoc> iter = mSortedSet.iterator(); GenomeLoc loc = iter.next(); assertEquals(loc.getStart(), 0); assertEquals(loc.getStop(), 100); assertEquals(loc.getContigIndex(), 1); } @Test public void overlap() { for (int i = 1; i < 6; i++) { final int start = i * 10; mSortedSet.add(genomeLocParser.createGenomeLoc(contigOneName, start, start + 1)); } // test matches in and around interval assertFalse(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 9, 9))); assertTrue(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 10, 10))); assertTrue(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 11, 11))); assertFalse(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 12, 12))); // test matches spanning intervals assertTrue(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 14, 20))); assertTrue(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 11, 15))); assertTrue(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 30, 40))); assertTrue(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 51, 53))); // test miss assertFalse(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 12, 19))); // test exact match after miss assertTrue(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 40, 41))); // test matches at beginning of intervals assertFalse(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 5, 6))); assertTrue(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 0, 10))); // test matches at end of intervals assertFalse(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 52, 53))); assertTrue(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 51, 53))); assertFalse(mSortedSet.overlaps(genomeLocParser.createGenomeLoc(contigOneName, 52, 53))); } @Test public void mergingOverlappingAbove() { GenomeLoc e = genomeLocParser.createGenomeLoc(contigOneName, 0, 50); GenomeLoc g = genomeLocParser.createGenomeLoc(contigOneName, 49, 100); assertTrue(mSortedSet.size() == 0); mSortedSet.add(g); assertTrue(mSortedSet.size() == 1); mSortedSet.addRegion(e); assertTrue(mSortedSet.size() == 1); Iterator<GenomeLoc> iter = mSortedSet.iterator(); GenomeLoc loc = iter.next(); assertEquals(loc.getStart(), 0); assertEquals(loc.getStop(), 100); assertEquals(loc.getContigIndex(), 1); } @Test public void deleteAllByRegion() { GenomeLoc e = genomeLocParser.createGenomeLoc(contigOneName, 1, 100); mSortedSet.add(e); for (int x = 1; x < 101; x++) { GenomeLoc del = genomeLocParser.createGenomeLoc(contigOneName, x, x); mSortedSet = mSortedSet.subtractRegions(new GenomeLocSortedSet(genomeLocParser, del)); } assertTrue(mSortedSet.isEmpty()); } @Test public void deleteSomeByRegion() { GenomeLoc e = genomeLocParser.createGenomeLoc(contigOneName, 1, 100); mSortedSet.add(e); for (int x = 1; x < 50; x++) { GenomeLoc del = genomeLocParser.createGenomeLoc(contigOneName, x, x); mSortedSet = mSortedSet.subtractRegions(new GenomeLocSortedSet(genomeLocParser, del)); } assertTrue(!mSortedSet.isEmpty()); assertTrue(mSortedSet.size() == 1); GenomeLoc loc = mSortedSet.iterator().next(); assertTrue(loc.getStop() == 100); assertTrue(loc.getStart() == 50); } @Test public void deleteSuperRegion() { GenomeLoc e = genomeLocParser.createGenomeLoc(contigOneName, 10, 20); GenomeLoc g = genomeLocParser.createGenomeLoc(contigOneName, 70, 100); mSortedSet.add(g); mSortedSet.addRegion(e); assertTrue(mSortedSet.size() == 2); // now delete a region GenomeLoc d = genomeLocParser.createGenomeLoc(contigOneName, 15, 75); mSortedSet = mSortedSet.subtractRegions(new GenomeLocSortedSet(genomeLocParser, d)); Iterator<GenomeLoc> iter = mSortedSet.iterator(); GenomeLoc loc = iter.next(); assertTrue(loc.getStart() == 10); assertTrue(loc.getStop() == 14); assertTrue(loc.getContigIndex() == 1); loc = iter.next(); assertTrue(loc.getStart() == 76); assertTrue(loc.getStop() == 100); assertTrue(loc.getContigIndex() == 1); } @Test public void substractComplexExample() { GenomeLoc e = genomeLocParser.createGenomeLoc(contigOneName, 1, 20); mSortedSet.add(e); GenomeLoc r1 = genomeLocParser.createGenomeLoc(contigOneName, 3, 5); GenomeLoc r2 = genomeLocParser.createGenomeLoc(contigOneName, 10, 12); GenomeLoc r3 = genomeLocParser.createGenomeLoc(contigOneName, 16, 18); GenomeLocSortedSet toExclude = new GenomeLocSortedSet(genomeLocParser, Arrays.asList(r1, r2, r3)); GenomeLocSortedSet remaining = mSortedSet.subtractRegions(toExclude); // logger.debug("Initial " + mSortedSet); // logger.debug("Exclude " + toExclude); // logger.debug("Remaining " + remaining); assertEquals(mSortedSet.coveredSize(), 20); assertEquals(toExclude.coveredSize(), 9); assertEquals(remaining.coveredSize(), 11); Iterator<GenomeLoc> it = remaining.iterator(); GenomeLoc p1 = it.next(); GenomeLoc p2 = it.next(); GenomeLoc p3 = it.next(); GenomeLoc p4 = it.next(); assertEquals(genomeLocParser.createGenomeLoc(contigOneName, 1, 2), p1); assertEquals(genomeLocParser.createGenomeLoc(contigOneName, 6, 9), p2); assertEquals(genomeLocParser.createGenomeLoc(contigOneName, 13, 15), p3); assertEquals(genomeLocParser.createGenomeLoc(contigOneName, 19, 20), p4); } private void testSizeBeforeLocX(int pos, int size) { GenomeLoc test = genomeLocParser.createGenomeLoc(contigOneName, pos, pos); assertEquals( mSortedSet.sizeBeforeLoc(test), size, String.format("X pos=%d size=%d", pos, size)); } @Test public void testSizeBeforeLoc() { GenomeLoc r1 = genomeLocParser.createGenomeLoc(contigOneName, 3, 5); GenomeLoc r2 = genomeLocParser.createGenomeLoc(contigOneName, 10, 12); GenomeLoc r3 = genomeLocParser.createGenomeLoc(contigOneName, 16, 18); mSortedSet.addAll(Arrays.asList(r1, r2, r3)); testSizeBeforeLocX(2, 0); testSizeBeforeLocX(3, 0); testSizeBeforeLocX(4, 1); testSizeBeforeLocX(5, 2); testSizeBeforeLocX(6, 3); testSizeBeforeLocX(10, 3); testSizeBeforeLocX(11, 4); testSizeBeforeLocX(12, 5); testSizeBeforeLocX(13, 6); testSizeBeforeLocX(15, 6); testSizeBeforeLocX(16, 6); testSizeBeforeLocX(17, 7); testSizeBeforeLocX(18, 8); testSizeBeforeLocX(19, 9); testSizeBeforeLocX(50, 9); testSizeBeforeLocX(50, (int) mSortedSet.coveredSize()); } @Test public void fromSequenceDictionary() { mSortedSet = GenomeLocSortedSet.createSetFromSequenceDictionary(this.header.getSequenceDictionary()); // we should have sequence assertTrue(mSortedSet.size() == GenomeLocSortedSetUnitTest.NUMBER_OF_CHROMOSOMES); int seqNumber = 0; for (GenomeLoc loc : mSortedSet) { assertTrue(loc.getStart() == 1); assertTrue(loc.getStop() == GenomeLocSortedSetUnitTest.CHROMOSOME_SIZE); assertTrue(loc.getContigIndex() == seqNumber); ++seqNumber; } assertTrue(seqNumber == GenomeLocSortedSetUnitTest.NUMBER_OF_CHROMOSOMES); } // ----------------------------------------------------------------------------------------------- // // Test getOverlapping // // ----------------------------------------------------------------------------------------------- @DataProvider(name = "GetOverlapping") public Object[][] makeGetOverlappingTest() throws Exception { final GenomeLocParser genomeLocParser = new GenomeLocParser(new CachingIndexedFastaSequenceFile(new File(b37KGReference))); List<Object[]> tests = new ArrayList<Object[]>(); final GenomeLoc prev1 = genomeLocParser.createGenomeLoc("19", 1, 10); final GenomeLoc prev2 = genomeLocParser.createGenomeLoc("19", 20, 50); final GenomeLoc post1 = genomeLocParser.createGenomeLoc("21", 1, 10); final GenomeLoc post2 = genomeLocParser.createGenomeLoc("21", 20, 50); final int chr20Length = genomeLocParser.getContigs().getSequence("20").getSequenceLength(); for (final int regionStart : Arrays.asList(1, 10, chr20Length - 10, chr20Length)) { for (final int regionSize : Arrays.asList(1, 10, 100)) { final GenomeLoc region = genomeLocParser.createGenomeLocOnContig("20", regionStart, regionStart + regionSize); final GenomeLoc spanning = genomeLocParser.createGenomeLocOnContig("20", regionStart - 10, region.getStop() + 10); final GenomeLoc before_into = genomeLocParser.createGenomeLocOnContig("20", regionStart - 10, regionStart + 1); final GenomeLoc middle = genomeLocParser.createGenomeLocOnContig("20", regionStart + 1, regionStart + 2); final GenomeLoc middle_past = genomeLocParser.createGenomeLocOnContig( "20", region.getStop() - 1, region.getStop() + 10); final List<GenomeLoc> potentials = new LinkedList<GenomeLoc>(); potentials.add(region); if (spanning != null) potentials.add(spanning); if (before_into != null) potentials.add(before_into); if (middle != null) potentials.add(middle); if (middle_past != null) potentials.add(middle_past); for (final int n : Arrays.asList(1, 2, 3)) { for (final List<GenomeLoc> regions : Utils.makePermutations(potentials, n, false)) { tests.add(new Object[] {new GenomeLocSortedSet(genomeLocParser, regions), region}); tests.add( new Object[] { new GenomeLocSortedSet(genomeLocParser, Utils.append(regions, prev1)), region }); tests.add( new Object[] { new GenomeLocSortedSet(genomeLocParser, Utils.append(regions, prev1, prev2)), region }); tests.add( new Object[] { new GenomeLocSortedSet(genomeLocParser, Utils.append(regions, post1)), region }); tests.add( new Object[] { new GenomeLocSortedSet(genomeLocParser, Utils.append(regions, post1, post2)), region }); tests.add( new Object[] { new GenomeLocSortedSet(genomeLocParser, Utils.append(regions, prev1, post1)), region }); tests.add( new Object[] { new GenomeLocSortedSet( genomeLocParser, Utils.append(regions, prev1, prev2, post1, post2)), region }); } } } } return tests.toArray(new Object[][] {}); } @Test(dataProvider = "GetOverlapping") public void testGetOverlapping(final GenomeLocSortedSet intervals, final GenomeLoc region) { final List<GenomeLoc> expectedOverlapping = intervals.getOverlappingFullSearch(region); final List<GenomeLoc> actualOverlapping = intervals.getOverlapping(region); Assert.assertEquals(actualOverlapping, expectedOverlapping); Assert.assertEquals( intervals.overlaps(region), !expectedOverlapping.isEmpty(), "GenomeLocSortedSet.overlaps didn't return expected result"); } }