From 1509dcc262689f904e30afeaa561ac7e30a4b8ec Mon Sep 17 00:00:00 2001 From: jmthibault79 Date: Sat, 2 Mar 2019 09:00:20 -0500 Subject: [PATCH] Consolidate common code into CRAMStructureTestUtil: (#1312) - ContainerTest, ContainerFactoryTest, ContainerParserTest, SliceTests, and CRAMBAIIndexerTest --- .../htsjdk/samtools/CRAMBAIIndexerTest.java | 93 ++++----- .../cram/build/ContainerFactoryTest.java | 90 +++------ .../cram/build/ContainerParserTest.java | 31 +-- ...rdUtil.java => CRAMStructureTestUtil.java} | 124 ++++++++---- .../cram/structure/ContainerTest.java | 151 +++++++-------- .../samtools/cram/structure/SliceTests.java | 181 +++++------------- 6 files changed, 290 insertions(+), 380 deletions(-) rename src/test/java/htsjdk/samtools/cram/structure/{CramCompressionRecordUtil.java => CRAMStructureTestUtil.java} (51%) diff --git a/src/test/java/htsjdk/samtools/CRAMBAIIndexerTest.java b/src/test/java/htsjdk/samtools/CRAMBAIIndexerTest.java index 98e1c9708b..980201da50 100644 --- a/src/test/java/htsjdk/samtools/CRAMBAIIndexerTest.java +++ b/src/test/java/htsjdk/samtools/CRAMBAIIndexerTest.java @@ -4,84 +4,65 @@ import htsjdk.samtools.cram.build.ContainerFactory; import htsjdk.samtools.cram.structure.Container; import htsjdk.samtools.cram.structure.CramCompressionRecord; -import htsjdk.samtools.cram.structure.Slice; +import htsjdk.samtools.cram.structure.CRAMStructureTestUtil; import htsjdk.samtools.seekablestream.SeekableMemoryStream; import org.testng.Assert; import org.testng.annotations.Test; import java.io.ByteArrayOutputStream; +import java.io.IOException; import java.util.ArrayList; -import java.util.Collections; import java.util.List; /** * Created by vadim on 12/01/2016. */ public class CRAMBAIIndexerTest extends HtsjdkTest { + @Test + public void test_processMultiContainer() throws IOException { + // 1 record with ref id 0 + // 3 records with ref id 1 + // 2 records with ref id 2 - private static CramCompressionRecord createRecord(int recordIndex, int seqId, int start) { - byte[] bases = "AAAAA".getBytes(); - int readLength = bases.length; - - final CramCompressionRecord record = new CramCompressionRecord(); - record.setSegmentUnmapped(false); - record.setMultiFragment(false); - record.sequenceId = seqId; - record.alignmentStart = start; - record.readBases = record.qualityScores = bases; - record.readName = Integer.toString(recordIndex); - record.readLength = readLength; - record.readFeatures = Collections.emptyList(); + final int expected0 = 1; + final int expected1 = 3; + final int expected2 = 2; - return record; - } - @Test - public void test_processMultiContainer() { - SAMFileHeader samFileHeader = new SAMFileHeader(); - samFileHeader.addSequence(new SAMSequenceRecord("1", 10)); - samFileHeader.addSequence(new SAMSequenceRecord("2", 10)); - samFileHeader.addSequence(new SAMSequenceRecord("3", 10)); - ByteArrayOutputStream indexBAOS = new ByteArrayOutputStream(); - CRAMBAIIndexer indexer = new CRAMBAIIndexer(indexBAOS, samFileHeader); - int recordsPerContainer = 3; - ContainerFactory containerFactory = new ContainerFactory(samFileHeader, recordsPerContainer); - List records = new ArrayList<>(); - records.add(createRecord(0, 0, 1)); - records.add(createRecord(1, 1, 2)); - records.add(createRecord(2, 1, 3)); + final List records1 = new ArrayList<>(); + records1.add(CRAMStructureTestUtil.createMappedRecord(0, 0, 1)); + records1.add(CRAMStructureTestUtil.createMappedRecord(1, 1, 2)); + records1.add(CRAMStructureTestUtil.createMappedRecord(2, 1, 3)); - final Container container1 = containerFactory.buildContainer(records); - Assert.assertNotNull(container1); - Assert.assertEquals(container1.nofRecords, records.size()); - Assert.assertTrue(container1.getReferenceContext().isMultiRef()); + final List records2 = new ArrayList<>(); + records2.add(CRAMStructureTestUtil.createMappedRecord(3, 1, 3)); + records2.add(CRAMStructureTestUtil.createMappedRecord(4, 2, 3)); + records2.add(CRAMStructureTestUtil.createMappedRecord(5, 2, 4)); - indexer.processContainer(container1, ValidationStringency.STRICT); + final SAMFileHeader samFileHeader = CRAMStructureTestUtil.getSAMFileHeaderForTests(); - records.clear(); - records.add(createRecord(3, 1, 3)); - records.add(createRecord(4, 2, 3)); - records.add(createRecord(5, 2, 4)); - final Container container2 = containerFactory.buildContainer(records); - Assert.assertNotNull(container2); - Assert.assertEquals(container2.nofRecords, records.size()); - Assert.assertTrue(container2.getReferenceContext().isMultiRef()); + final int recordsPerContainer = 3; + final ContainerFactory containerFactory = new ContainerFactory(samFileHeader, recordsPerContainer); - indexer.processContainer(container2, ValidationStringency.STRICT); + final Container container1 = containerFactory.buildContainer(records1); + Assert.assertTrue(container1.getReferenceContext().isMultiRef()); - indexer.finish(); + final Container container2 = containerFactory.buildContainer(records2); + Assert.assertTrue(container2.getReferenceContext().isMultiRef()); - BAMIndex index = new CachingBAMFileIndex(new SeekableMemoryStream(indexBAOS.toByteArray(), null), samFileHeader.getSequenceDictionary()); - final BAMIndexMetaData metaData_0 = index.getMetaData(0); - Assert.assertNotNull(metaData_0); - Assert.assertEquals(metaData_0.getAlignedRecordCount(), 1); + byte[] indexBytes; + try (final ByteArrayOutputStream indexBAOS = new ByteArrayOutputStream()) { + final CRAMBAIIndexer indexer = new CRAMBAIIndexer(indexBAOS, samFileHeader); + indexer.processContainer(container1, ValidationStringency.STRICT); + indexer.processContainer(container2, ValidationStringency.STRICT); + indexer.finish(); + indexBytes = indexBAOS.toByteArray(); + } - final BAMIndexMetaData metaData_1 = index.getMetaData(1); - Assert.assertNotNull(metaData_1); - Assert.assertEquals(metaData_1.getAlignedRecordCount(), 3); + final BAMIndex index = new CachingBAMFileIndex(new SeekableMemoryStream(indexBytes, null), samFileHeader.getSequenceDictionary()); - final BAMIndexMetaData metaData_2 = index.getMetaData(2); - Assert.assertNotNull(metaData_2); - Assert.assertEquals(metaData_2.getAlignedRecordCount(), 2); + Assert.assertEquals(index.getMetaData(0).getAlignedRecordCount(), expected0); + Assert.assertEquals(index.getMetaData(1).getAlignedRecordCount(), expected1); + Assert.assertEquals(index.getMetaData(2).getAlignedRecordCount(), expected2); } } diff --git a/src/test/java/htsjdk/samtools/cram/build/ContainerFactoryTest.java b/src/test/java/htsjdk/samtools/cram/build/ContainerFactoryTest.java index fa4c7441f1..697a63eb06 100644 --- a/src/test/java/htsjdk/samtools/cram/build/ContainerFactoryTest.java +++ b/src/test/java/htsjdk/samtools/cram/build/ContainerFactoryTest.java @@ -4,9 +4,8 @@ import htsjdk.samtools.cram.ref.ReferenceContext; import htsjdk.samtools.cram.structure.Container; import htsjdk.samtools.cram.structure.CramCompressionRecord; -import htsjdk.samtools.cram.structure.CramCompressionRecordUtil; +import htsjdk.samtools.cram.structure.CRAMStructureTestUtil; import htsjdk.samtools.cram.structure.Slice; -import org.testng.Assert; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; @@ -17,25 +16,30 @@ */ public class ContainerFactoryTest extends HtsjdkTest { private static final int TEST_RECORD_COUNT = 10; + private static final int READ_LENGTH_FOR_TEST_RECORDS = CRAMStructureTestUtil.READ_LENGTH_FOR_TEST_RECORDS; @DataProvider(name = "containerStateTests") private Object[][] containerStateTests() { final int mappedSequenceId = 0; // arbitrary final ReferenceContext mappedRefContext = new ReferenceContext(mappedSequenceId); final int mappedAlignmentStart = 1; - final int mappedAlignmentSpan = CramCompressionRecordUtil.READ_LENGTH_FOR_TEST_RECORDS + TEST_RECORD_COUNT - 1; + // record spans: + // [1 to READ_LENGTH_FOR_TEST_RECORDS] + // [2 to READ_LENGTH_FOR_TEST_RECORDS + 1] + // up to [TEST_RECORD_COUNT to READ_LENGTH_FOR_TEST_RECORDS + TEST_RECORD_COUNT - 1] + final int mappedAlignmentSpan = READ_LENGTH_FOR_TEST_RECORDS + TEST_RECORD_COUNT - 1; return new Object[][]{ { - CramCompressionRecordUtil.getSingleRefRecords(TEST_RECORD_COUNT, mappedSequenceId), + CRAMStructureTestUtil.getSingleRefRecords(TEST_RECORD_COUNT, mappedSequenceId), mappedRefContext, mappedAlignmentStart, mappedAlignmentSpan }, { - CramCompressionRecordUtil.getMultiRefRecords(TEST_RECORD_COUNT), + CRAMStructureTestUtil.getMultiRefRecords(TEST_RECORD_COUNT), ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN }, { - CramCompressionRecordUtil.getUnmappedRecords(TEST_RECORD_COUNT), + CRAMStructureTestUtil.getUnmappedRecords(TEST_RECORD_COUNT), ReferenceContext.UNMAPPED_UNPLACED_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN }, @@ -43,25 +47,25 @@ private Object[][] containerStateTests() { // but not both. We treat these weird edge cases as unplaced. { - CramCompressionRecordUtil.getHalfUnmappedNoRefRecords(TEST_RECORD_COUNT), + CRAMStructureTestUtil.getHalfUnmappedNoRefRecords(TEST_RECORD_COUNT), ReferenceContext.UNMAPPED_UNPLACED_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN }, { - CramCompressionRecordUtil.getHalfUnmappedNoStartRecords(TEST_RECORD_COUNT, mappedSequenceId), + CRAMStructureTestUtil.getHalfUnmappedNoStartRecords(TEST_RECORD_COUNT, mappedSequenceId), ReferenceContext.UNMAPPED_UNPLACED_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN }, // show that unmapped-unplaced reads cause a single ref slice/container to become multiref { - CramCompressionRecordUtil.getSingleRefRecordsWithOneUnmapped(TEST_RECORD_COUNT, mappedSequenceId), + CRAMStructureTestUtil.getSingleRefRecordsWithOneUnmapped(TEST_RECORD_COUNT, mappedSequenceId), ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN }, // show that unmapped-unplaced reads don't change the state of a multi-ref slice/container { - CramCompressionRecordUtil.getMultiRefRecordsWithOneUnmapped(TEST_RECORD_COUNT), + CRAMStructureTestUtil.getMultiRefRecordsWithOneUnmapped(TEST_RECORD_COUNT), ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN }, }; @@ -73,77 +77,45 @@ public void testContainerState(final List records, final int expectedAlignmentStart, final int expectedAlignmentSpan) { final Container container = buildFromNewFactory(records); - assertContainerState(container, expectedReferenceContext, expectedAlignmentStart, expectedAlignmentSpan); + final int globalRecordCounter = 0; // first Container + final int baseCount = TEST_RECORD_COUNT * READ_LENGTH_FOR_TEST_RECORDS; + + CRAMStructureTestUtil.assertContainerState(container, expectedReferenceContext, + expectedAlignmentStart, expectedAlignmentSpan, + TEST_RECORD_COUNT, baseCount, globalRecordCounter); } @Test public void testMultiRefWithStateTransitions() { - final List containers = CramCompressionRecordUtil.getMultiRefContainersForStateTest(); + final List containers = CRAMStructureTestUtil.getMultiRefContainersForStateTest(); // first container is single-ref final ReferenceContext refContext = new ReferenceContext(0); final int alignmentStart = 1; - final int alignmentSpan = CramCompressionRecordUtil.READ_LENGTH_FOR_TEST_RECORDS; + final int alignmentSpan = READ_LENGTH_FOR_TEST_RECORDS; int recordCount = 1; int globalRecordCount = 0; // first container - no records yet - assertContainerState(containers.get(0), refContext, alignmentStart, alignmentSpan, - globalRecordCount, recordCount, CramCompressionRecordUtil.READ_LENGTH_FOR_TEST_RECORDS * recordCount); + CRAMStructureTestUtil.assertContainerState(containers.get(0), refContext, alignmentStart, alignmentSpan, + recordCount, READ_LENGTH_FOR_TEST_RECORDS * recordCount, globalRecordCount); // when other refs are added, subsequent containers are multiref recordCount++; // this container has 2 records globalRecordCount = containers.get(0).nofRecords; // we've seen 1 record before this container - assertContainerState(containers.get(1), ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN, - globalRecordCount, recordCount, CramCompressionRecordUtil.READ_LENGTH_FOR_TEST_RECORDS * recordCount); + CRAMStructureTestUtil.assertContainerState(containers.get(1), ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, + Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN, + recordCount, READ_LENGTH_FOR_TEST_RECORDS * recordCount, globalRecordCount); recordCount++; // this container has 3 records globalRecordCount = containers.get(0).nofRecords + containers.get(1).nofRecords; // we've seen 3 records before this container - assertContainerState(containers.get(2), ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN, - globalRecordCount, recordCount, CramCompressionRecordUtil.READ_LENGTH_FOR_TEST_RECORDS * recordCount); + CRAMStructureTestUtil.assertContainerState(containers.get(2), ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, + Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN, + recordCount, READ_LENGTH_FOR_TEST_RECORDS * recordCount, globalRecordCount); } private Container buildFromNewFactory(final List records) { - final ContainerFactory factory = new ContainerFactory(CramCompressionRecordUtil.getSAMFileHeaderForTests(), TEST_RECORD_COUNT); + final ContainerFactory factory = new ContainerFactory(CRAMStructureTestUtil.getSAMFileHeaderForTests(), TEST_RECORD_COUNT); return factory.buildContainer(records); } - - private void assertContainerState(final Container container, - final ReferenceContext referenceContext, - final int alignmentStart, - final int alignmentSpan) { - final int globalRecordCounter = 0; // first Container - final int baseCount = TEST_RECORD_COUNT * CramCompressionRecordUtil.READ_LENGTH_FOR_TEST_RECORDS; - - assertContainerState(container, referenceContext, alignmentStart, alignmentSpan, globalRecordCounter, TEST_RECORD_COUNT, baseCount); - } - - private static void assertContainerState(final Container container, - final ReferenceContext referenceContext, - final int alignmentStart, - final int alignmentSpan, - final int globalRecordCounter, - final int recordCount, - final int baseCount) { - Assert.assertNotNull(container); - Assert.assertEquals(container.getReferenceContext(), referenceContext); - Assert.assertEquals(container.alignmentStart, alignmentStart); - Assert.assertEquals(container.alignmentSpan, alignmentSpan); - Assert.assertEquals(container.nofRecords, recordCount); - Assert.assertEquals(container.globalRecordCounter, globalRecordCounter); - Assert.assertEquals(container.bases, baseCount); - - Assert.assertEquals(container.slices.length, 1); - - // verify the underlying slice too - - final Slice slice = container.slices[0]; - Assert.assertEquals(slice.getReferenceContext(), container.getReferenceContext()); - Assert.assertEquals(slice.globalRecordCounter, globalRecordCounter); - Assert.assertEquals(slice.alignmentStart, alignmentStart); - Assert.assertEquals(slice.alignmentSpan, alignmentSpan); - Assert.assertEquals(slice.nofRecords, recordCount); - Assert.assertEquals(slice.globalRecordCounter, globalRecordCounter); - Assert.assertEquals(slice.bases, baseCount); - } } diff --git a/src/test/java/htsjdk/samtools/cram/build/ContainerParserTest.java b/src/test/java/htsjdk/samtools/cram/build/ContainerParserTest.java index fdf7a343e0..ffff3d6852 100644 --- a/src/test/java/htsjdk/samtools/cram/build/ContainerParserTest.java +++ b/src/test/java/htsjdk/samtools/cram/build/ContainerParserTest.java @@ -2,6 +2,7 @@ import htsjdk.HtsjdkTest; import htsjdk.samtools.ValidationStringency; +import htsjdk.samtools.cram.structure.CRAMStructureTestUtil; import htsjdk.samtools.cram.common.CramVersions; import htsjdk.samtools.cram.common.Version; import htsjdk.samtools.cram.ref.ReferenceContext; @@ -20,18 +21,20 @@ */ public class ContainerParserTest extends HtsjdkTest { private static final int TEST_RECORD_COUNT = 10; - private static final ContainerFactory FACTORY = new ContainerFactory(CramCompressionRecordUtil.getSAMFileHeaderForTests(), TEST_RECORD_COUNT); - private static final ContainerParser PARSER = new ContainerParser(CramCompressionRecordUtil.getSAMFileHeaderForTests()); + private static final int READ_LENGTH_FOR_TEST_RECORDS = CRAMStructureTestUtil.READ_LENGTH_FOR_TEST_RECORDS; - @DataProvider(name = "eof") - private Object[][] eofData() { + private static final ContainerFactory FACTORY = new ContainerFactory(CRAMStructureTestUtil.getSAMFileHeaderForTests(), TEST_RECORD_COUNT); + private static final ContainerParser PARSER = new ContainerParser(CRAMStructureTestUtil.getSAMFileHeaderForTests()); + + @DataProvider(name = "cramVersions") + private Object[][] cramVersions() { return new Object[][] { {CramVersions.CRAM_v2_1}, {CramVersions.CRAM_v3} }; } - @Test(dataProvider = "eof") + @Test(dataProvider = "cramVersions") public void testEOF(final Version version) throws IOException { try (final ByteArrayOutputStream baos = new ByteArrayOutputStream()) { CramIO.issueEOF(version, baos); @@ -47,11 +50,11 @@ private Object[][] refTestData() { final ReferenceContext mappedRefContext = new ReferenceContext(mappedSequenceId); return new Object[][] { { - CramCompressionRecordUtil.getSingleRefRecords(TEST_RECORD_COUNT, mappedSequenceId), + CRAMStructureTestUtil.getSingleRefRecords(TEST_RECORD_COUNT, mappedSequenceId), Collections.singleton(mappedRefContext) }, { - CramCompressionRecordUtil.getUnmappedRecords(TEST_RECORD_COUNT), + CRAMStructureTestUtil.getUnmappedRecords(TEST_RECORD_COUNT), Collections.singleton(ReferenceContext.UNMAPPED_UNPLACED_CONTEXT) }, @@ -59,11 +62,11 @@ private Object[][] refTestData() { // but not both. We treat these weird edge cases as unplaced. { - CramCompressionRecordUtil.getHalfUnmappedNoRefRecords(TEST_RECORD_COUNT), + CRAMStructureTestUtil.getHalfUnmappedNoRefRecords(TEST_RECORD_COUNT), Collections.singleton(ReferenceContext.UNMAPPED_UNPLACED_CONTEXT) }, { - CramCompressionRecordUtil.getHalfUnmappedNoStartRecords(TEST_RECORD_COUNT, mappedSequenceId), + CRAMStructureTestUtil.getHalfUnmappedNoStartRecords(TEST_RECORD_COUNT, mappedSequenceId), Collections.singleton(ReferenceContext.UNMAPPED_UNPLACED_CONTEXT) }, }; @@ -86,10 +89,10 @@ public void paramTest(final List records, final Set expectedSpans = new HashMap<>(); for (int i = 0; i < TEST_RECORD_COUNT; i++) { - expectedSpans.put(new ReferenceContext(i), new AlignmentSpan(i + 1, CramCompressionRecordUtil.READ_LENGTH_FOR_TEST_RECORDS, 1)); + expectedSpans.put(new ReferenceContext(i), new AlignmentSpan(i + 1, READ_LENGTH_FOR_TEST_RECORDS, 1)); } - final Container container = FACTORY.buildContainer(CramCompressionRecordUtil.getMultiRefRecords(TEST_RECORD_COUNT)); + final Container container = FACTORY.buildContainer(CRAMStructureTestUtil.getMultiRefRecords(TEST_RECORD_COUNT)); final Map spanMap = PARSER.getReferences(container, ValidationStringency.STRICT); Assert.assertEquals(spanMap, expectedSpans); @@ -98,10 +101,10 @@ public void testMultirefContainer() { @Test public void testMultirefContainerWithUnmapped() { final List expectedSpans = new ArrayList<>(); - expectedSpans.add(new AlignmentSpan(1, CramCompressionRecordUtil.READ_LENGTH_FOR_TEST_RECORDS, 1)); - expectedSpans.add(new AlignmentSpan(2, CramCompressionRecordUtil.READ_LENGTH_FOR_TEST_RECORDS, 1)); + expectedSpans.add(new AlignmentSpan(1, READ_LENGTH_FOR_TEST_RECORDS, 1)); + expectedSpans.add(new AlignmentSpan(2, READ_LENGTH_FOR_TEST_RECORDS, 1)); - final List containers = CramCompressionRecordUtil.getMultiRefContainersForStateTest(); + final List containers = CRAMStructureTestUtil.getMultiRefContainersForStateTest(); // first container is single-ref diff --git a/src/test/java/htsjdk/samtools/cram/structure/CramCompressionRecordUtil.java b/src/test/java/htsjdk/samtools/cram/structure/CRAMStructureTestUtil.java similarity index 51% rename from src/test/java/htsjdk/samtools/cram/structure/CramCompressionRecordUtil.java rename to src/test/java/htsjdk/samtools/cram/structure/CRAMStructureTestUtil.java index 68a6def98d..9bc189d567 100644 --- a/src/test/java/htsjdk/samtools/cram/structure/CramCompressionRecordUtil.java +++ b/src/test/java/htsjdk/samtools/cram/structure/CRAMStructureTestUtil.java @@ -4,12 +4,14 @@ import htsjdk.samtools.SAMRecord; import htsjdk.samtools.SAMSequenceRecord; import htsjdk.samtools.cram.build.ContainerFactory; +import htsjdk.samtools.cram.ref.ReferenceContext; +import org.testng.Assert; import java.util.ArrayList; import java.util.Collections; import java.util.List; -public class CramCompressionRecordUtil { +public class CRAMStructureTestUtil { public static final int READ_LENGTH_FOR_TEST_RECORDS = 123; private static final SAMFileHeader header = initializeSAMFileHeaderForTests(); @@ -37,24 +39,35 @@ public static SAMFileHeader getSAMFileHeaderForTests() { return header; } - private static CramCompressionRecord createMappedRecord(final int alignmentStart, final int sequenceId) { + public static CramCompressionRecord createMappedRecord(final int index, + final int sequenceId, + final int alignmentStart) { final CramCompressionRecord record = new CramCompressionRecord(); + record.index = index; + record.sequenceId = sequenceId; + record.alignmentStart = alignmentStart; + record.setSegmentUnmapped(false); + record.readBases = "AAA".getBytes(); record.qualityScores = "!!!".getBytes(); record.readLength = READ_LENGTH_FOR_TEST_RECORDS; record.readName = "A READ NAME"; - record.sequenceId = sequenceId; - record.alignmentStart = alignmentStart + 1; record.setLastSegment(true); - record.setSegmentUnmapped(false); record.readFeatures = Collections.emptyList(); return record; } - public static List getSingleRefRecords(final int recordCount, final int sequenceId) { + public static CramCompressionRecord createUnmappedRecord(final int index) { + final CramCompressionRecord record = createMappedRecord(index, SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX, SAMRecord.NO_ALIGNMENT_START); + record.setSegmentUnmapped(true); + return record; + } + + public static List getSingleRefRecords(final int recordCount, + final int singleSequenceId) { final List records = new ArrayList<>(); for (int i = 0; i < recordCount; i++) { - final CramCompressionRecord record = createMappedRecord(i, sequenceId); + final CramCompressionRecord record = createMappedRecord(i, singleSequenceId, i + 1); // set half unmapped-but-placed, to show that it does not make a difference if (i % 2 == 0) { @@ -69,7 +82,7 @@ public static List getSingleRefRecords(final int recordCo public static List getMultiRefRecords(final int recordCount) { final List records = new ArrayList<>(); for (int i = 0; i < recordCount; i++) { - final CramCompressionRecord record = createMappedRecord(i, i); + final CramCompressionRecord record = createMappedRecord(i, i, i + 1); // set half unmapped-but-placed, to show that it does not make a difference if (i % 2 == 0) { @@ -84,21 +97,20 @@ public static List getMultiRefRecords(final int recordCou public static List getUnmappedRecords(final int recordCount) { final List records = new ArrayList<>(); for (int i = 0; i < recordCount; i++) { - final CramCompressionRecord record = createMappedRecord(i, SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX); - record.setSegmentUnmapped(true); - record.alignmentStart = SAMRecord.NO_ALIGNMENT_START; + final CramCompressionRecord record = createUnmappedRecord(i); records.add(record); } return records; } + // these two sets of records are "half" unplaced: they have either a valid reference index or start position, // but not both. We treat these weird edge cases as unplaced. public static List getHalfUnmappedNoRefRecords(final int recordCount) { final List records = new ArrayList<>(); for (int i = 0; i < recordCount; i++) { - final CramCompressionRecord record = createMappedRecord(i, SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX); + final CramCompressionRecord record = createMappedRecord(i, SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX, i + 1); record.setSegmentUnmapped(true); records.add(record); } @@ -108,28 +120,22 @@ public static List getHalfUnmappedNoRefRecords(final int public static List getHalfUnmappedNoStartRecords(final int recordCount, final int sequenceId) { final List records = new ArrayList<>(); for (int i = 0; i < recordCount; i++) { - final CramCompressionRecord record = createMappedRecord(i, sequenceId); + final CramCompressionRecord record = createMappedRecord(i, sequenceId, SAMRecord.NO_ALIGNMENT_START); record.setSegmentUnmapped(true); - record.alignmentStart = SAMRecord.NO_ALIGNMENT_START; - record.setLastSegment(true); records.add(record); } return records; } public static List getSingleRefRecordsWithOneUnmapped(final int testRecordCount, final int mappedSequenceId) { - final List retval = getSingleRefRecords(testRecordCount, mappedSequenceId); - retval.get(0).setSegmentUnmapped(true); - retval.get(0).alignmentStart = SAMRecord.NO_ALIGNMENT_START; - retval.get(0).sequenceId = SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX; + final List retval = getSingleRefRecords(testRecordCount - 1, mappedSequenceId); + retval.add(createUnmappedRecord(testRecordCount - 1)); return retval; } public static List getMultiRefRecordsWithOneUnmapped(final int testRecordCount) { - final List retval = getMultiRefRecords(testRecordCount); - retval.get(0).setSegmentUnmapped(true); - retval.get(0).alignmentStart = SAMRecord.NO_ALIGNMENT_START; - retval.get(0).sequenceId = SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX; + final List retval = getMultiRefRecords(testRecordCount - 1); + retval.add(createUnmappedRecord(testRecordCount - 1)); return retval; } @@ -139,18 +145,16 @@ public static List getMultiRefContainersForStateTest() { final List records = new ArrayList<>(); - final CramCompressionRecord record0 = createMappedRecord(0, 0); - records.add(record0); + int index = 0; + records.add(createMappedRecord(index, index, index + 1)); final Container container0 = factory.buildContainer(records); - final CramCompressionRecord record1 = createMappedRecord(1, 1); - records.add(record1); + index++; + records.add(createMappedRecord(index, index, index + 1)); final Container container1 = factory.buildContainer(records); - final CramCompressionRecord unmapped = createMappedRecord(2, SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX); - unmapped.alignmentStart = SAMRecord.NO_ALIGNMENT_START; - unmapped.setSegmentUnmapped(true); - records.add(unmapped); + index++; + records.add(createUnmappedRecord(index)); final Container container2 = factory.buildContainer(records); testContainers.add(container0); @@ -158,4 +162,60 @@ public static List getMultiRefContainersForStateTest() { testContainers.add(container2); return testContainers; } -} + + // assert that slices and containers have values equal to what the caller expects + + public static void assertSliceState(final Slice slice, + final ReferenceContext expectedReferenceContext, + final int expectedAlignmentStart, + final int expectedAlignmentSpan, + final int expectedRecordCount, + final int expectedBaseCount) { + Assert.assertEquals(slice.getReferenceContext(), expectedReferenceContext); + Assert.assertEquals(slice.alignmentStart, expectedAlignmentStart); + Assert.assertEquals(slice.alignmentSpan, expectedAlignmentSpan); + Assert.assertEquals(slice.nofRecords, expectedRecordCount); + Assert.assertEquals(slice.bases, expectedBaseCount); + } + + public static void assertSliceState(final Slice slice, + final ReferenceContext expectedReferenceContext, + final int expectedAlignmentStart, + final int expectedAlignmentSpan, + final int expectedRecordCount, + final int expectedBaseCount, + final int expectedGlobalRecordCounter) { + assertSliceState(slice, expectedReferenceContext, expectedAlignmentStart, expectedAlignmentSpan, expectedRecordCount, expectedBaseCount); + Assert.assertEquals(slice.globalRecordCounter, expectedGlobalRecordCounter); + } + + public static void assertContainerState(final Container container, + final ReferenceContext expectedReferenceContext, + final int expectedAlignmentStart, + final int expectedAlignmentSpan) { + Assert.assertEquals(container.getReferenceContext(), expectedReferenceContext); + Assert.assertEquals(container.alignmentStart, expectedAlignmentStart); + Assert.assertEquals(container.alignmentSpan, expectedAlignmentSpan); + } + + public static void assertContainerState(final Container container, + final ReferenceContext expectedReferenceContext, + final int expectedAlignmentStart, + final int expectedAlignmentSpan, + final int expectedRecordCount, + final int expectedBaseCount, + final int expectedGlobalRecordCounter) { + assertContainerState(container, expectedReferenceContext, expectedAlignmentStart, expectedAlignmentSpan); + + Assert.assertEquals(container.nofRecords, expectedRecordCount); + Assert.assertEquals(container.bases, expectedBaseCount); + Assert.assertEquals(container.globalRecordCounter, expectedGlobalRecordCounter); + + Assert.assertEquals(container.slices.length, 1); + + // verify the underlying slice too + + assertSliceState(container.slices[0], expectedReferenceContext, expectedAlignmentStart, expectedAlignmentSpan, + expectedRecordCount, expectedBaseCount, expectedGlobalRecordCounter); + } +} \ No newline at end of file diff --git a/src/test/java/htsjdk/samtools/cram/structure/ContainerTest.java b/src/test/java/htsjdk/samtools/cram/structure/ContainerTest.java index 0d2975cff9..a7a35f0bbb 100644 --- a/src/test/java/htsjdk/samtools/cram/structure/ContainerTest.java +++ b/src/test/java/htsjdk/samtools/cram/structure/ContainerTest.java @@ -3,102 +3,83 @@ import htsjdk.HtsjdkTest; import htsjdk.samtools.cram.CRAMException; import htsjdk.samtools.cram.ref.ReferenceContext; -import htsjdk.samtools.cram.ref.ReferenceContextType; -import org.testng.Assert; +import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import java.util.Arrays; +import java.util.List; public class ContainerTest extends HtsjdkTest { - @Test - public static void singleRefSliceStateTest() { - final Slice slice = new Slice(new ReferenceContext(5)); - slice.alignmentStart = 10; - slice.alignmentSpan = 15; - - final Container container = Container.initializeFromSlices(Arrays.asList(slice)); - - Assert.assertTrue(container.getReferenceContext().isMappedSingleRef()); - Assert.assertEquals(container.getReferenceContext().getType(), ReferenceContextType.SINGLE_REFERENCE_TYPE); - Assert.assertEquals(container.getReferenceContext(), slice.getReferenceContext()); - Assert.assertEquals(container.alignmentStart, slice.alignmentStart); - Assert.assertEquals(container.alignmentSpan, slice.alignmentSpan); + @DataProvider(name = "containerStateTestCases") + private Object[][] containerStateTestCases() { + final ReferenceContext mappedReferenceContext = new ReferenceContext(5); // arbitrary + + final int slice1AlignmentStart = 10; + final int slice1AlignmentSpan = 15; + final Slice mappedSlice1 = new Slice(mappedReferenceContext); + mappedSlice1.alignmentStart = slice1AlignmentStart; + mappedSlice1.alignmentSpan = slice1AlignmentSpan; + + final int slice2AlignmentStart = 20; + final int slice2AlignmentSpan = 20; + final Slice mappedSlice2 = new Slice(mappedReferenceContext); + mappedSlice2.alignmentStart = slice2AlignmentStart; + mappedSlice2.alignmentSpan = slice2AlignmentSpan; + final int expectedSpan = slice2AlignmentStart + slice2AlignmentSpan - slice1AlignmentStart; + + return new Object[][] { + { + Arrays.asList(mappedSlice1), mappedReferenceContext, slice1AlignmentStart, slice1AlignmentSpan + }, + { + Arrays.asList(mappedSlice1, mappedSlice2), mappedReferenceContext, slice1AlignmentStart, expectedSpan + }, + { + Arrays.asList(new Slice(ReferenceContext.MULTIPLE_REFERENCE_CONTEXT), + new Slice(ReferenceContext.MULTIPLE_REFERENCE_CONTEXT)), + ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN + }, + { + Arrays.asList(new Slice(ReferenceContext.UNMAPPED_UNPLACED_CONTEXT), + new Slice(ReferenceContext.UNMAPPED_UNPLACED_CONTEXT)), + ReferenceContext.UNMAPPED_UNPLACED_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN + }, + }; } - @Test - public static void singleRefSliceMultipleStateTest() { - final Slice slice1 = new Slice(new ReferenceContext(5)); - slice1.alignmentStart = 10; - slice1.alignmentSpan = 15; - - final Slice slice2 = new Slice(slice1.getReferenceContext()); - slice2.alignmentStart = 20; - slice2.alignmentSpan = 20; - - final Container container = Container.initializeFromSlices(Arrays.asList(slice1, slice2)); - - Assert.assertTrue(container.getReferenceContext().isMappedSingleRef()); - Assert.assertEquals(container.getReferenceContext().getType(), ReferenceContextType.SINGLE_REFERENCE_TYPE); - Assert.assertEquals(container.getReferenceContext(), slice1.getReferenceContext()); - Assert.assertEquals(container.alignmentStart, slice1.alignmentStart); - Assert.assertEquals(container.alignmentSpan, slice2.alignmentStart + slice2.alignmentSpan - slice1.alignmentStart); // 20 + 20 - 10 + @Test(dataProvider = "containerStateTestCases") + public void initializeFromSlicesTest(final List slices, + final ReferenceContext expectedReferenceContext, + final int expectedAlignmentStart, + final int expectedAlignmentSpan) { + final Container container = Container.initializeFromSlices(slices); + CRAMStructureTestUtil.assertContainerState(container, expectedReferenceContext, expectedAlignmentStart, expectedAlignmentSpan); } - @Test - public static void multiRefSliceStateTest() { - final Slice slice1 = new Slice(ReferenceContext.MULTIPLE_REFERENCE_CONTEXT); - final Slice slice2 = new Slice(ReferenceContext.MULTIPLE_REFERENCE_CONTEXT); - - final Container container = Container.initializeFromSlices(Arrays.asList(slice1, slice2)); - - Assert.assertTrue(container.getReferenceContext().isMultiRef()); - Assert.assertEquals(container.getReferenceContext().getType(), ReferenceContextType.MULTIPLE_REFERENCE_TYPE); - Assert.assertEquals(container.alignmentStart, Slice.NO_ALIGNMENT_START); - Assert.assertEquals(container.alignmentSpan, Slice.NO_ALIGNMENT_SPAN); - } - - @Test - public static void unmappedSliceStateTest() { - final Slice slice1 = new Slice(ReferenceContext.UNMAPPED_UNPLACED_CONTEXT); - final Slice slice2 = new Slice(ReferenceContext.UNMAPPED_UNPLACED_CONTEXT); - - final Container container = Container.initializeFromSlices(Arrays.asList(slice1, slice2)); - - Assert.assertTrue(container.getReferenceContext().isUnmappedUnplaced()); - Assert.assertEquals(container.getReferenceContext().getType(), ReferenceContextType.UNMAPPED_UNPLACED_TYPE); - Assert.assertEquals(container.alignmentStart, Slice.NO_ALIGNMENT_START); - Assert.assertEquals(container.alignmentSpan, Slice.NO_ALIGNMENT_SPAN); + @DataProvider(name = "illegalCombinationTestCases") + private Object[][] illegalCombinationTestCases() { + return new Object[][] { + { + new Slice(new ReferenceContext(0)), + new Slice(new ReferenceContext(1)) + }, + { + new Slice(new ReferenceContext(0)), + new Slice(ReferenceContext.UNMAPPED_UNPLACED_CONTEXT) + }, + { + new Slice(new ReferenceContext(0)), + new Slice(ReferenceContext.MULTIPLE_REFERENCE_CONTEXT) + }, + { + new Slice(ReferenceContext.UNMAPPED_UNPLACED_CONTEXT), + new Slice(ReferenceContext.MULTIPLE_REFERENCE_CONTEXT) + }, + }; } - @Test(expectedExceptions = CRAMException.class) - public static void differentReferencesStateTest() { - final Slice one = new Slice(new ReferenceContext(5)); - final Slice another = new Slice(new ReferenceContext(2)); - + @Test(dataProvider = "illegalCombinationTestCases", expectedExceptions = CRAMException.class) + public static void illegalCombinationsStateTest(final Slice one, final Slice another) { Container.initializeFromSlices(Arrays.asList(one, another)); } - - @Test(expectedExceptions = CRAMException.class) - public static void singleAndUnmappedStateTest() { - final Slice single = new Slice(new ReferenceContext(5)); - final Slice unmapped = new Slice(ReferenceContext.UNMAPPED_UNPLACED_CONTEXT); - - Container.initializeFromSlices(Arrays.asList(single, unmapped)); - } - - @Test(expectedExceptions = CRAMException.class) - public static void multiAndSingleStateTest() { - final Slice multi = new Slice(ReferenceContext.MULTIPLE_REFERENCE_CONTEXT); - final Slice single = new Slice(new ReferenceContext(5)); - - Container.initializeFromSlices(Arrays.asList(multi, single)); - } - - @Test(expectedExceptions = CRAMException.class) - public static void multiAndUnmappedStateTest() { - final Slice multi = new Slice(ReferenceContext.MULTIPLE_REFERENCE_CONTEXT); - final Slice unmapped = new Slice(ReferenceContext.UNMAPPED_UNPLACED_CONTEXT); - - Container.initializeFromSlices(Arrays.asList(multi, unmapped)); - } } diff --git a/src/test/java/htsjdk/samtools/cram/structure/SliceTests.java b/src/test/java/htsjdk/samtools/cram/structure/SliceTests.java index f5d70841d3..5c97838757 100644 --- a/src/test/java/htsjdk/samtools/cram/structure/SliceTests.java +++ b/src/test/java/htsjdk/samtools/cram/structure/SliceTests.java @@ -16,7 +16,6 @@ import java.io.File; import java.io.IOException; import java.util.ArrayList; -import java.util.Collections; import java.util.Iterator; import java.util.List; @@ -24,8 +23,8 @@ * Created by vadim on 07/12/2015. */ public class SliceTests extends HtsjdkTest { - private final int TEST_RECORD_COUNT = 10; - private final int READ_LENGTH_FOR_TEST_RECORDS = 123; + private static final int TEST_RECORD_COUNT = 10; + private static final int READ_LENGTH_FOR_TEST_RECORDS = CRAMStructureTestUtil.READ_LENGTH_FOR_TEST_RECORDS; @Test public void testUnmappedValidateRef() { @@ -74,27 +73,29 @@ public void testFailsMD5Check() throws IOException { } } - @DataProvider(name = "forBuildTests") - private Object[][] forBuildTests() { + @DataProvider(name = "sliceStateTestCases") + private Object[][] sliceStateTestCases() { + final int mappedSequenceId = 0; // arbitrary + final ReferenceContext mappedRefContext = new ReferenceContext(mappedSequenceId); final List retval = new ArrayList<>(); final boolean[] coordinateSorteds = new boolean[] { true, false }; for (final boolean coordSorted : coordinateSorteds) { retval.add(new Object[] { - getSingleRefRecords(), + CRAMStructureTestUtil.getSingleRefRecords(TEST_RECORD_COUNT, mappedSequenceId), coordSorted, - new ReferenceContext(0), 1, + mappedRefContext, 1, READ_LENGTH_FOR_TEST_RECORDS + TEST_RECORD_COUNT - 1 }); retval.add(new Object[] { - getMultiRefRecords(), + CRAMStructureTestUtil.getMultiRefRecords(TEST_RECORD_COUNT), coordSorted, ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN }); retval.add(new Object[] { - getUnplacedRecords(), + CRAMStructureTestUtil.getUnmappedRecords(TEST_RECORD_COUNT), coordSorted, ReferenceContext.UNMAPPED_UNPLACED_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN }); @@ -105,14 +106,14 @@ private Object[][] forBuildTests() { retval.add(new Object[] { - getNoRefRecords(), + CRAMStructureTestUtil.getHalfUnmappedNoRefRecords(TEST_RECORD_COUNT), coordSorted, ReferenceContext.UNMAPPED_UNPLACED_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN }); retval.add(new Object[] { - getNoStartRecords(), + CRAMStructureTestUtil.getHalfUnmappedNoStartRecords(TEST_RECORD_COUNT, mappedSequenceId), coordSorted, ReferenceContext.UNMAPPED_UNPLACED_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN }); @@ -121,17 +122,17 @@ private Object[][] forBuildTests() { return retval.toArray(new Object[0][0]); } - @Test(dataProvider = "forBuildTests") - public void testBuild(final List records, - final boolean coordinateSorted, - final ReferenceContext expectedReferenceContext, - final int expectedAlignmentStart, - final int expectedAlignmentSpan) { + @Test(dataProvider = "sliceStateTestCases") + public void sliceStateTest(final List records, + final boolean coordinateSorted, + final ReferenceContext expectedReferenceContext, + final int expectedAlignmentStart, + final int expectedAlignmentSpan) { final CompressionHeader header = new CompressionHeaderFactory().build(records, null, coordinateSorted); final Slice slice = Slice.buildSlice(records, header); final int expectedBaseCount = TEST_RECORD_COUNT * READ_LENGTH_FOR_TEST_RECORDS; - assertSliceState(slice, expectedReferenceContext, expectedAlignmentStart, expectedAlignmentSpan, - TEST_RECORD_COUNT, expectedBaseCount); + CRAMStructureTestUtil.assertSliceState(slice, expectedReferenceContext, + expectedAlignmentStart, expectedAlignmentSpan, TEST_RECORD_COUNT, expectedBaseCount); } // show that a slice with a single ref will initially be built as single-ref @@ -142,37 +143,41 @@ public void testBuild(final List records, public void testBuildStates() { final List records = new ArrayList<>(); - final CramCompressionRecord record1 = createRecord(0, 0); + int index = 0; + final int alignmentStart = 100; // arbitrary + final CramCompressionRecord record1 = CRAMStructureTestUtil.createMappedRecord(index, index, alignmentStart); records.add(record1); - assertSliceStateFromTestRecords(records, new ReferenceContext(0), 1, READ_LENGTH_FOR_TEST_RECORDS); + buildSliceAndAssert(records, new ReferenceContext(index), alignmentStart, READ_LENGTH_FOR_TEST_RECORDS); - final CramCompressionRecord record2 = createRecord(1, 1); + index++; + final CramCompressionRecord record2 = CRAMStructureTestUtil.createMappedRecord(index, index, alignmentStart); records.add(record2); - assertSliceStateFromTestRecords(records, ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN); + buildSliceAndAssert(records, ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN); - final CramCompressionRecord record3 = createRecord(2, 2); + index++; + final CramCompressionRecord record3 = CRAMStructureTestUtil.createMappedRecord(index, index, alignmentStart); records.add(record3); - assertSliceStateFromTestRecords(records, ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN); + buildSliceAndAssert(records, ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN); - final CramCompressionRecord unmapped = createRecord(3, SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX); - unmapped.alignmentStart = SAMRecord.NO_ALIGNMENT_START; - unmapped.setSegmentUnmapped(true); + index++; + final CramCompressionRecord unmapped = CRAMStructureTestUtil.createUnmappedRecord(index); records.add(unmapped); - assertSliceStateFromTestRecords(records, ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN); + buildSliceAndAssert(records, ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN); } @Test public void testSingleAndUnmappedBuild() { final List records = new ArrayList<>(); - final CramCompressionRecord single = createRecord(1, 0); + final int mappedSequenceId = 0; // arbitrary + final int alignmentStart = 10; // arbitrary + int index = 0; + final CramCompressionRecord single = CRAMStructureTestUtil.createMappedRecord(index, mappedSequenceId, alignmentStart); single.readLength = 20; records.add(single); - final CramCompressionRecord unmapped = createRecord(1, 0); - unmapped.sequenceId = SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX; - unmapped.alignmentStart = SAMRecord.NO_ALIGNMENT_START; - unmapped.setSegmentUnmapped(true); + index++; + final CramCompressionRecord unmapped = CRAMStructureTestUtil.createUnmappedRecord(index); unmapped.readLength = 35; records.add(unmapped); @@ -180,111 +185,19 @@ public void testSingleAndUnmappedBuild() { final Slice slice = Slice.buildSlice(records, header); final int expectedBaseCount = single.readLength + unmapped.readLength; - assertSliceState(slice, ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN, - records.size(), expectedBaseCount); + CRAMStructureTestUtil.assertSliceState(slice, ReferenceContext.MULTIPLE_REFERENCE_CONTEXT, + Slice.NO_ALIGNMENT_START, Slice.NO_ALIGNMENT_SPAN, records.size(), expectedBaseCount); } - private void assertSliceStateFromTestRecords(final List records, - final ReferenceContext expectedReferenceContext, - final int expectedAlignmentStart, - final int expectedAlignmentSpan) { + private static void buildSliceAndAssert(final List records, + final ReferenceContext expectedReferenceContext, + final int expectedAlignmentStart, + final int expectedAlignmentSpan) { final CompressionHeader header = new CompressionHeaderFactory().build(records, null, true); final Slice slice = Slice.buildSlice(records, header); final int expectedBaseCount = records.size() * READ_LENGTH_FOR_TEST_RECORDS; - assertSliceState(slice, expectedReferenceContext, expectedAlignmentStart, expectedAlignmentSpan, - records.size(), expectedBaseCount); + CRAMStructureTestUtil.assertSliceState(slice, expectedReferenceContext, + expectedAlignmentStart, expectedAlignmentSpan, records.size(), expectedBaseCount); } - private void assertSliceState(final Slice slice, - final ReferenceContext expectedReferenceContext, - final int expectedAlignmentStart, - final int expectedAlignmentSpan, - final int expectedRecordCount, - final int expectedBaseCount) { - - Assert.assertEquals(slice.getReferenceContext(), expectedReferenceContext); - Assert.assertEquals(slice.alignmentStart, expectedAlignmentStart); - Assert.assertEquals(slice.alignmentSpan, expectedAlignmentSpan); - Assert.assertEquals(slice.nofRecords, expectedRecordCount); - Assert.assertEquals(slice.bases, expectedBaseCount); - } - - private CramCompressionRecord createRecord(final int index, - final int sequenceId) { - final CramCompressionRecord record = new CramCompressionRecord(); - record.readBases = "AAA".getBytes(); - record.qualityScores = "!!!".getBytes(); - record.readLength = READ_LENGTH_FOR_TEST_RECORDS; - record.readName = "" + index; - record.sequenceId = sequenceId; - record.alignmentStart = index + 1; - record.setLastSegment(true); - record.readFeatures = Collections.emptyList(); - record.setSegmentUnmapped(false); - return record; - } - - // set half of the records created as unmapped, alternating by index - - private CramCompressionRecord createRecordHalfUnmapped(final int index, - final int sequenceId) { - final CramCompressionRecord record = createRecord(index, sequenceId); - if (index % 2 == 0) { - record.setSegmentUnmapped(true); - } else { - record.setSegmentUnmapped(false); - } - return record; - } - - private List getSingleRefRecords() { - final List records = new ArrayList<>(); - for (int index = 0; index < TEST_RECORD_COUNT; index++) { - records.add(createRecordHalfUnmapped(index, 0)); - } - return records; - } - - private List getMultiRefRecords() { - final List records = new ArrayList<>(); - for (int index = 0; index < TEST_RECORD_COUNT; index++) { - records.add(createRecordHalfUnmapped(index, index)); - } - return records; - } - - private List getUnplacedRecords() { - final List records = new ArrayList<>(); - for (int index = 0; index < TEST_RECORD_COUNT; index++) { - final CramCompressionRecord record = createRecord(index, SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX); - record.alignmentStart = SAMRecord.NO_ALIGNMENT_START; - record.setSegmentUnmapped(true); - records.add(record); - } - return records; - } - - // these two sets of records are "half" unplaced: they have either a valid reference index or start position, - // but not both. We treat these weird edge cases as unplaced. - - private List getNoRefRecords() { - final List records = new ArrayList<>(); - for (int index = 0; index < TEST_RECORD_COUNT; index++) { - final CramCompressionRecord record = createRecord(index, SAMRecord.NO_ALIGNMENT_REFERENCE_INDEX); - record.setSegmentUnmapped(true); - records.add(record); - } - return records; - } - - private List getNoStartRecords() { - final List records = new ArrayList<>(); - for (int index = 0; index < TEST_RECORD_COUNT; index++) { - final CramCompressionRecord record = createRecord(index, index); - record.alignmentStart = SAMRecord.NO_ALIGNMENT_START; - record.setSegmentUnmapped(true); - records.add(record); - } - return records; - } }