import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
/**
 * Gets the next complete in-frame codon from the given {@link ReferenceSequence} according to the current codon position and strand.
 * @param referenceSequence The {@link ReferenceSequence} for the current codon.  Must not be {@code null}.
 * @param currentAlignedCodingSequenceAlleleStart The starting position (1-based, inclusive) of the current codon.  Must be > 0.
 * @param currentAlignedCodingSequenceAlleleStop The ending position (1-based, inclusive) of the current codon.  Must be > 0.
 * @param strand The {@link Strand} on which the current codon resides.  Must not be {@code null}.  Must not be {@link Strand#NONE}.
 * @return The next codon in frame with the current codon as specified by the given current codon positions.
 */
private static String getNextReferenceCodon(final ReferenceSequence referenceSequence,
                                            final int currentAlignedCodingSequenceAlleleStart,
                                            final int currentAlignedCodingSequenceAlleleStop,
                                            final Strand strand) {

    Utils.nonNull( referenceSequence );
    ParamUtils.isPositive(currentAlignedCodingSequenceAlleleStart, "Genomic positions must be > 0.");
    ParamUtils.isPositive(currentAlignedCodingSequenceAlleleStop, "Genomic positions must be > 0.");
    assertValidStrand(strand);

    final String nextRefCodon;
    if ( strand == Strand.POSITIVE ) {
        nextRefCodon = referenceSequence.getBaseString().substring(currentAlignedCodingSequenceAlleleStop, currentAlignedCodingSequenceAlleleStop + 3 );
    }
    else {
        nextRefCodon = ReadUtils.getBasesReverseComplement(
                referenceSequence.getBaseString().substring(currentAlignedCodingSequenceAlleleStart - 3, currentAlignedCodingSequenceAlleleStart ).getBytes()
        );
    }
    return nextRefCodon;
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
/**
 * Gets the requested number of complete in-frame codons from the given {@link ReferenceSequence} that follow the given current codon position and strand.
 * @param referenceSequence The {@link ReferenceSequence} for the current codon.  Must not be {@code null}.
 * @param currentAlignedCodingSequenceAlleleStart The starting position (1-based, inclusive) of the current codon.  Must be > 0.
 * @param currentAlignedCodingSequenceAlleleStop The ending position (1-based, inclusive) of the current codon.  Must be > 0.
 * @param strand The {@link Strand} on which the current codon resides.  Must not be {@code null}.  Must not be {@link Strand#NONE}.
 * @param numAdditionalCodonsToGet The number of codons to return.
 * @return The {@link List} of codons (as {@link String}s) in frame with the current codon as specified by the given current codon positions.
 */
private static List<String> getNextReferenceCodons(final ReferenceSequence referenceSequence,
                                                   final int currentAlignedCodingSequenceAlleleStart,
                                                   final int currentAlignedCodingSequenceAlleleStop,
                                                   final Strand strand,
                                                   final int numAdditionalCodonsToGet) {

    ParamUtils.isPositiveOrZero( numAdditionalCodonsToGet, "Must specify a positive number of codons to return (or zero)." );

    final ArrayList<String> nextCodons = new ArrayList<>(numAdditionalCodonsToGet);

    for (int i = 0; i < numAdditionalCodonsToGet; ++i) {
        final String nextCodon = getNextReferenceCodon(referenceSequence, currentAlignedCodingSequenceAlleleStart + (i*3), currentAlignedCodingSequenceAlleleStop + (i*3), strand);
        nextCodons.add(nextCodon);
    }

    return nextCodons;
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
/**
 * Gets the start position relative to the start of the coding sequence for a variant based on the given {@code variantGenomicStartPosition}.
 * It is assumed:
 *      {@code codingRegionGenomicStartPosition} <= {@code variantGenomicStartPosition} <= {@code codingRegionGenomicEndPosition}
 * The transcript start position is the genomic position the transcript starts assuming `+` traversal.  That is, it is the lesser of start position and end position.
 * This is important because we determine the relative positions based on which direction the transcript is read.
 * @param variantGenomicStartPosition Start position (1-based, inclusive) of a variant in the genome.  Must be > 0.
 * @param codingRegionGenomicStartPosition Start position (1-based, inclusive) of a transcript in the genome.  Must be > 0.
 * @param codingRegionGenomicEndPosition End position (1-based, inclusive) of a transcript in the genome.  Must be > 0.
 * @param strand {@link Strand} from which strand the associated transcript is read.  Must not be {@code null}.  Must not be {@link Strand#NONE}.
 * @return The start position (1-based, inclusive) relative to the start of the coding sequence of a variant.
 */
public static int getTranscriptAlleleStartPosition(final int variantGenomicStartPosition,
                                                   final int codingRegionGenomicStartPosition,
                                                   final int codingRegionGenomicEndPosition,
                                                   final Strand strand) {

    ParamUtils.isPositive( variantGenomicStartPosition, "Genome positions must be > 0." );
    ParamUtils.isPositive( codingRegionGenomicStartPosition, "Genome positions must be > 0." );
    ParamUtils.isPositive( codingRegionGenomicEndPosition, "Genome positions must be > 0." );
    assertValidStrand( strand );

    if ( strand == Strand.POSITIVE ) {
        return variantGenomicStartPosition - codingRegionGenomicStartPosition + 1;
    }
    else {
        return codingRegionGenomicEndPosition - variantGenomicStartPosition + 1;
    }
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
/**
 * Creates a {@link GencodeFuncotation}s based on the given {@link Allele} with type
 * {@link GencodeFuncotation.VariantClassification#IGR}.
 * Reports reference bases as if they are on the {@link Strand#POSITIVE} strand.
 * @param refAllele The reference {@link Allele} to use for this {@link GencodeFuncotation}.
 * @param altAllele The alternate {@link Allele} to use for this {@link GencodeFuncotation}.
 * @param reference The {@link ReferenceContext} in which the given {@link Allele}s appear.
 * @return An IGR funcotation for the given allele.
 */
private static GencodeFuncotation createIgrFuncotation(final Allele refAllele,
                                                       final Allele altAllele,
                                                       final ReferenceContext reference){

    final GencodeFuncotationBuilder funcotationBuilder = new GencodeFuncotationBuilder();

    // Get GC Content:
    funcotationBuilder.setGcContent( calculateGcContent( reference, gcContentWindowSizeBases ) );

    funcotationBuilder.setVariantClassification( GencodeFuncotation.VariantClassification.IGR );
    funcotationBuilder.setRefAlleleAndStrand( refAllele, Strand.POSITIVE );
    funcotationBuilder.setTumorSeqAllele1( altAllele.getBaseString() );
    funcotationBuilder.setTumorSeqAllele2( altAllele.getBaseString() );

    final String referenceBases = FuncotatorUtils.getBasesInWindowAroundReferenceAllele(refAllele, altAllele, Strand.POSITIVE, referenceWindow, reference);

    // Set our reference context in the the FuncotatonBuilder:
    funcotationBuilder.setReferenceContext( referenceBases );

    return funcotationBuilder.build();
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
/**
 * Set {@link GencodeFuncotation#refAllele} and {@link GencodeFuncotation#transcriptStrand} based on the strand and the allele itself.
 *
 * @param refAllele The reference {@link Allele} to set.  Assumed to be the FORWARD direction transcription (regardless of the value of {@code strand}).
 * @param strand    The {@link Strand} on which the gene in this funcotation occurs.
 * @return {@code this} {@link GencodeFuncotationBuilder}.
 */
public GencodeFuncotationBuilder setRefAlleleAndStrand(final Allele refAllele, final Strand strand) {

    FuncotatorUtils.assertValidStrand(strand);

    if (strand == Strand.POSITIVE) {
        gencodeFuncotation.setRefAllele(refAllele.getBaseString());
        gencodeFuncotation.setTranscriptStrand("+");
    } else {
        gencodeFuncotation.setRefAllele(
                ReadUtils.getBasesReverseComplement(refAllele.getBases())
        );
        gencodeFuncotation.setTranscriptStrand("-");
    }

    return this;
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
private static Object[] helpCreateDataForTestGetBasesInWindowAroundReferenceAllele(final String refAlelleBases,
                                                                                   final String altAlleleBases,
                                                                                   final String strand,
                                                                                   final int windowSizeInBases,
                                                                                   final int startPos,
                                                                                   final int endPos,
                                                                                   final String expected) {
    return new Object[] {
        Allele.create(refAlelleBases, true),
            Allele.create(altAlleleBases),
            Strand.decode(strand),
            windowSizeInBases,
            new ReferenceContext( refDataSourceHg19Ch3, new SimpleInterval("chr3", startPos, endPos) ),
            expected
    };
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
private void parseAndSetStrand(String[] tokens, int tokenCount, NggbSimpleBedFeature feature) {
    if (tokenCount > STRAND_OFFSET) {
        String strandString = tokens[STRAND_OFFSET].trim();
        char strand = strandString.isEmpty() ? ' ' : strandString.charAt(0);

        if (strand == '-') {
            feature.setStrand(Strand.NEGATIVE);
        } else if (strand == '+') {
            feature.setStrand(Strand.POSITIVE);
        } else {
            feature.setStrand(Strand.NONE);
        }
    }
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
private void createExons(int start, String[] tokens, FullBEDFeature gene,
                         Strand strand) throws NumberFormatException {

    int cdStart = Integer.parseInt(tokens[6]) + startOffsetValue;
    int cdEnd = Integer.parseInt(tokens[7]);

    int exonCount = Integer.parseInt(tokens[9]);
    String[] exonSizes = new String[exonCount];
    String[] startsBuffer = new String[exonCount];
    ParsingUtils.split(tokens[10], exonSizes, ',');
    ParsingUtils.split(tokens[11], startsBuffer, ',');

    int exonNumber = (strand == Strand.NEGATIVE ? exonCount : 1);

    if (startsBuffer.length == exonSizes.length) {
        for (int i = 0; i < startsBuffer.length; i++) {
            int exonStart = start + Integer.parseInt(startsBuffer[i]);
            int exonEnd = exonStart + Integer.parseInt(exonSizes[i]) - 1;
            gene.addExon(exonStart, exonEnd, cdStart, cdEnd, exonNumber);

            if (strand == Strand.NEGATIVE) {
                exonNumber--;
            } else {
                exonNumber++;
            }
        }
    }
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
public void setStrand(final Strand strand) {

        if (strand == Strand.NONE) {
            throw new GATKException("Cannot handle NONE strand.");
        }

        this.strand = strand;
    }
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
/**
 * Get a string of bases around a variant (specified by reference and alternate alleles), including the reference allele itself.
 * ASSUMES: that the given {@link ReferenceContext} is already centered on the variant location.
 * @param refAllele The reference {@link Allele} for the variant in question.  If on {@link Strand#NEGATIVE}, must have already been reverse complemented.  Must not be {@code null}.
 * @param altAllele The alternate {@link Allele} for the variant in question.  If on {@link Strand#NEGATIVE}, must have already been reverse complemented.  Must not be {@code null}.
 * @param strand The {@link Strand} on which the variant in question lives.  Must not be {@code null}.  Must not be {@link Strand#NONE}.
 * @param referenceWindowInBases The number of bases to the left and right of the variant to return.  Must be > 0.
 * @param referenceContext The {@link ReferenceContext} centered around the variant in question.  Must not be {@code null}.
 * @return A string containing {@code referenceWindowInBases} bases to either side of the specified refAllele.
 */
public static String getBasesInWindowAroundReferenceAllele( final Allele refAllele,
                                                            final Allele altAllele,
                                                            final Strand strand,
                                                            final int referenceWindowInBases,
                                                            final ReferenceContext referenceContext) {
    Utils.nonNull( refAllele );
    Utils.nonNull( altAllele );
    assertValidStrand( strand );
    Utils.nonNull( referenceContext );

    // Calculate our window to include any extra bases but also have the right referenceWindowInBases:
    final int endWindow = refAllele.length() >= altAllele.length() ? referenceWindowInBases + refAllele.length() - 1 : referenceWindowInBases + altAllele.length() - 1;

    final String referenceBases;

    if ( strand == Strand.POSITIVE ) {
        // Get the reference sequence:
        referenceBases = new String(referenceContext.getBases(referenceWindowInBases, endWindow));
    }
    else {
        // Get the reference sequence:
        referenceBases = ReadUtils.getBasesReverseComplement(referenceContext.getBases(referenceWindowInBases, endWindow));
    }

    return referenceBases;
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
/**
 * Creates a {@link GencodeFuncotationBuilder} with some of the fields populated.
 * @param variant The {@link VariantContext} for the current variant.
 * @param altAllele The alternate {@link Allele} we are currently annotating.
 * @param gtfFeature The current {@link GencodeGtfGeneFeature} read from the input feature file.
 * @param transcript The current {@link GencodeGtfTranscriptFeature} containing our {@code alternateAllele}.
 * @return A trivially populated {@link GencodeFuncotationBuilder} object.
 */
 private static GencodeFuncotationBuilder createGencodeFuncotationBuilderWithTrivialFieldsPopulated(final VariantContext variant,
                                                                                                    final Allele altAllele,
                                                                                                    final GencodeGtfGeneFeature gtfFeature,
                                                                                                    final GencodeGtfTranscriptFeature transcript) {

     final GencodeFuncotationBuilder gencodeFuncotationBuilder = new GencodeFuncotationBuilder();
     final Strand strand = Strand.decode(transcript.getGenomicStrand().toString());

     gencodeFuncotationBuilder.setRefAlleleAndStrand(variant.getReference(), strand)
             .setHugoSymbol(gtfFeature.getGeneName())
             .setNcbiBuild(gtfFeature.getUcscGenomeVersion())
             .setChromosome(gtfFeature.getChromosomeName())
             .setStart(variant.getStart());

     // The end position is inclusive, so we need to make sure we don't double-count the start position (so we subtract 1):
     gencodeFuncotationBuilder.setEnd(variant.getStart() + altAllele.length() - 1)
             .setVariantType(getVariantType(variant.getReference(), altAllele))
             .setTumorSeqAllele1(altAllele.getBaseString())
             .setTumorSeqAllele2(altAllele.getBaseString())
             .setGenomeChange(getGenomeChangeString(variant, altAllele, gtfFeature))
             .setAnnotationTranscript(transcript.getTranscriptId())
             .setTranscriptPos(
                     FuncotatorUtils.getTranscriptAlleleStartPosition(variant.getStart(), transcript.getStart(), transcript.getEnd(), strand)
             )
             .setOtherTranscripts(
                gtfFeature.getTranscripts().stream().map(GencodeGtfTranscriptFeature::getTranscriptId).collect(Collectors.toList())
             );

     // Check for the optional non-serialized values for sorting:
     // NOTE: This is kind of a kludge:
     gencodeFuncotationBuilder.setLocusLevel( Integer.valueOf(gtfFeature.getLocusLevel().toString()) );

    // Check for existence of Appris Rank and set it:
     gencodeFuncotationBuilder.setApprisRank( getApprisRank( gtfFeature ) );

     // Get the length of the transcript:
     // NOTE: We add 1 because of genomic cordinates:
     gencodeFuncotationBuilder.setTranscriptLength( transcript.getEnd() - transcript.getStart() + 1);return gencodeFuncotationBuilder;
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
@DataProvider
Object[][] provideReferenceAndExonListForGatkExceptions() {

    return new Object[][] {
            {
                    new ReferenceContext(new ReferenceFileSource(TEST_REFERENCE), new SimpleInterval(TEST_REFERENCE_CONTIG, TEST_REFERENCE_START, TEST_REFERENCE_END)),
                    Collections.singletonList(
                            new SimpleInterval("2", TEST_REFERENCE_START + 500, TEST_REFERENCE_START + 550)
                    ),
                    Strand.POSITIVE
            },
            {
                    new ReferenceContext(new ReferenceFileSource(TEST_REFERENCE), new SimpleInterval(TEST_REFERENCE_CONTIG, TEST_REFERENCE_START, TEST_REFERENCE_END)),
                    Collections.singletonList(
                            new SimpleInterval("2", TEST_REFERENCE_START + 500, TEST_REFERENCE_START + 550)
                    ),
                    Strand.NEGATIVE
            },
            {
                    new ReferenceContext(new ReferenceFileSource(TEST_REFERENCE), new SimpleInterval(TEST_REFERENCE_CONTIG, TEST_REFERENCE_START, TEST_REFERENCE_END)),
                    Collections.singletonList(
                            new SimpleInterval("2", TEST_REFERENCE_START + 500, TEST_REFERENCE_START + 550)
                    ),
                    Strand.NONE
            },
    };
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
@DataProvider
Object[][] provideDataForGetStartPositionInTranscript() {

    final List<? extends Locatable> exons_forward = Arrays.asList(
            new SimpleInterval("chr1", 10,19),
            new SimpleInterval("chr1", 30,39),
            new SimpleInterval("chr1", 50,59),
            new SimpleInterval("chr1", 70,79),
            new SimpleInterval("chr1", 90,99)
    );

    final List<? extends Locatable> exons_backward = Arrays.asList(
            new SimpleInterval("chr1", 90,99),
            new SimpleInterval("chr1", 70,79),
            new SimpleInterval("chr1", 50,59),
            new SimpleInterval("chr1", 30,39),
            new SimpleInterval("chr1", 10,19)
    );

    return new Object[][] {
            { new SimpleInterval("chr1", 1, 1),     exons_forward, Strand.POSITIVE, -1 },
            { new SimpleInterval("chr1", 25, 67),   exons_forward, Strand.POSITIVE, -1 },
            { new SimpleInterval("chr1", 105, 392), exons_forward, Strand.POSITIVE, -1 },
            { new SimpleInterval("chr1", 10, 10),   exons_forward, Strand.POSITIVE,  1 },
            { new SimpleInterval("chr1", 99, 99),   exons_forward, Strand.POSITIVE, 50 },
            { new SimpleInterval("chr1", 50, 67),   exons_forward, Strand.POSITIVE, 21 },
            { new SimpleInterval("chr1", 67, 75),   exons_forward, Strand.POSITIVE, -1 },

            { new SimpleInterval("chr1", 1, 1),     exons_backward, Strand.NEGATIVE, -1 },
            { new SimpleInterval("chr1", 25, 67),   exons_backward, Strand.NEGATIVE, -1 },
            { new SimpleInterval("chr1", 105, 392), exons_backward, Strand.NEGATIVE, -1 },
            { new SimpleInterval("chr1", 10, 10),   exons_backward, Strand.NEGATIVE, 50 },
            { new SimpleInterval("chr1", 99, 99),   exons_backward, Strand.NEGATIVE,  1 },
            { new SimpleInterval("chr1", 50, 67),   exons_backward, Strand.NEGATIVE, -1 },
            { new SimpleInterval("chr1", 67, 75),   exons_backward, Strand.NEGATIVE, 15 },
    };
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
@DataProvider
Object[][] provideDataForGetTranscriptAlleleStartPosition() {

    return new Object[][] {
            { 1,  1, 10, Strand.POSITIVE,  1},
            { 5,  1, 10, Strand.POSITIVE,  5},
            { 10, 1, 10, Strand.POSITIVE, 10},

            { 1,  1, 10, Strand.NEGATIVE, 10},
            { 5,  1, 10, Strand.NEGATIVE,  6},
            { 10, 1, 10, Strand.NEGATIVE,  1},
    };
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
@DataProvider
Object[][] provideDataForTestCreateSpliceSiteCodonChange() {

    return new Object[][] {
            {1000, 5, 1000, 1500, Strand.POSITIVE, 0, "c.e5-0"},
            {1000, 4, 1, 1500, Strand.POSITIVE,    0, "c.e4+500"},
            {1000, 3, 500, 1500, Strand.POSITIVE,  0, "c.e3-500"},

            {1000, 5, 1000, 1500, Strand.NEGATIVE, 0, "c.e5+0"},
            {1000, 4, 1, 1500, Strand.NEGATIVE,    0, "c.e4-500"},
            {1000, 3, 500, 1500, Strand.NEGATIVE,  0, "c.e3+500"},

            {1000, 5, 1500, 500, Strand.NEGATIVE,  0, "c.e5+500"},

            {1000, 5, 1000, 1500, Strand.POSITIVE, 1, "c.e5+1"},
            {1000, 4, 1, 1500, Strand.POSITIVE,    2, "c.e4+502"},
            {1000, 3, 500, 1500, Strand.POSITIVE,  3, "c.e3-497"},

            {1000, 5, 1000, 1500, Strand.NEGATIVE, 4, "c.e5+4"},
            {1000, 4, 1, 1500, Strand.NEGATIVE,    5, "c.e4-495"},
            {1000, 3, 500, 1500, Strand.NEGATIVE,  6, "c.e3+506"},

            {1000, 5, 1500, 500, Strand.NEGATIVE,  7, "c.e5+507"},

            {1000, 5, 1000, 1500, Strand.POSITIVE, -1, "c.e5-1"},
            {1000, 4, 1, 1500, Strand.POSITIVE,    -2, "c.e4+498"},
            {1000, 3, 500, 1500, Strand.POSITIVE,  -3, "c.e3-503"},

            {1000, 5, 1000, 1500, Strand.NEGATIVE, -4, "c.e5-4"},
            {1000, 4, 1, 1500, Strand.NEGATIVE,    -5, "c.e4-505"},
            {1000, 3, 500, 1500, Strand.NEGATIVE,  -6, "c.e3+494"},

            {1000, 5, 1500, 500, Strand.NEGATIVE,  -7, "c.e5+493"},
    };
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
@DataProvider
Object[][] provideDataForTestAssertValidStrand_ValidStrands() {
    return new Object[][] {
            { Strand.POSITIVE },
            { Strand.NEGATIVE },
    };
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
@DataProvider
Object[][] provideDataForTestAssertValidStrand_InvalidStrands() {
    return new Object[][] {
            { null },
            { Strand.NONE }
    };
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
@Test (dataProvider = "provideDataForGetAlignedCodingSequenceAllele")
void testGetAlignedCodingSequenceAllele(  final String codingSequence,
                            final Integer alignedAlleleStart,
                            final Integer alignedAlleleStop,
                            final Allele refAllele,
                            final Integer refAlleleStart,
                            final Strand strand,
                            final String expected) {
    final String alignedRefAllele = FuncotatorUtils.getAlignedCodingSequenceAllele(codingSequence, alignedAlleleStart, alignedAlleleStop, refAllele, refAlleleStart, strand);
    Assert.assertEquals( alignedRefAllele, expected );
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
@Test (dataProvider = "provideDataForTestCreateSpliceSiteCodonChange")
void testCreateSpliceSiteCodonChange(final int variantStart,
                                     final int exonNumber,
                                     final int exonStart,
                                     final int exonEnd,
                                     final Strand strand,
                                     final int offsetIndelAdjustment,
                                     final String expected) {

    Assert.assertEquals( FuncotatorUtils.createSpliceSiteCodonChange(variantStart, exonNumber, exonStart, exonEnd, strand, offsetIndelAdjustment), expected );
}
 

import htsjdk.tribble.annotation.Strand; //导入依赖的package包/类
@Test (dataProvider = "provideDataForTestGetOverlappingExonPositions")
void testGetOverlappingExonPositions(final Allele refAllele,
                                     final Allele altAllele,
                                     final String contig,
                                     final int start,
                                     final int stop,
                                     final Strand strand,
                                     final List<? extends htsjdk.samtools.util.Locatable> exonPositionList,
                                     final SimpleInterval expected) {
    Assert.assertEquals( FuncotatorUtils.getOverlappingExonPositions(refAllele, altAllele, contig, start, stop, strand, exonPositionList), expected);
}