use noodles::sam;
use noodles::sam::alignment::RecordBuf;
use crate::testing::{Frag, Pair, SamBuilder, Strand};
use crate::{Error, is_fr_pair, template_end_distance};
fn pair(
start1: usize,
cigar1: &str,
reverse1: bool,
start2: usize,
cigar2: &str,
reverse2: bool,
) -> (sam::Header, Vec<RecordBuf>) {
let strand = |reverse: bool| if reverse { Strand::Minus } else { Strand::Plus };
let mut builder = SamBuilder::new();
let records = builder.add_pair(
Pair::at(start1, start2)
.name("q")
.cigar1(cigar1)
.cigar2(cigar2)
.strand1(strand(reverse1))
.strand2(strand(reverse2)),
);
(builder.header().clone(), records)
}
fn fr(header: &sam::Header, records: &[RecordBuf]) -> Vec<bool> {
records
.iter()
.map(|record| is_fr_pair(record, header).unwrap())
.collect()
}
fn ends(header: &sam::Header, records: &[RecordBuf], position: usize) -> Vec<Option<usize>> {
records
.iter()
.map(|record| template_end_distance(record, header, position).unwrap())
.collect()
}
type Vector = (&'static str, usize, usize, bool, usize, usize, bool, bool);
#[rustfmt::skip]
const VECTORS: [Vector; 16] = [
("normal innie", 1, 100, false, 500, 100, true, true),
("overlapping innie", 1, 100, false, 50, 100, true, true),
("second end enclosed innie", 1, 100, false, 50, 50, true, true),
("first end enclosed innie", 1, 50, false, 1, 100, true, true),
("completely overlapping innie", 1, 100, false, 1, 100, true, true),
("normal outie", 1, 100, true, 500, 100, false, false),
("nojump outie", 1, 100, true, 101, 100, false, false),
("forward tandem", 1, 100, true, 500, 100, true, false),
("reverse tandem", 1, 100, false, 500, 100, false, false),
("overlapping forward tandem", 1, 100, true, 50, 100, true, false),
("overlapping reverse tandem", 1, 100, false, 50, 100, false, false),
("second end enclosed forward tandem", 1, 100, true, 50, 50, true, false),
("second end enclosed reverse tandem", 1, 100, false, 50, 50, false, false),
("first end enclosed forward tandem", 1, 50, true, 1, 100, true, false),
("first end enclosed reverse tandem", 1, 50, false, 1, 100, false, false),
("dovetail 5' tie", 100, 100, false, 1, 100, true, true),
];
#[test]
fn test_htsjdk_pair_orientation_vectors() {
for (name, start1, length1, reverse1, start2, length2, reverse2, expected) in VECTORS {
let (header, records) = pair(
start1,
&format!("{length1}M"),
reverse1,
start2,
&format!("{length2}M"),
reverse2,
);
assert_eq!(fr(&header, &records), [expected, expected], "{name}");
}
}
#[test]
fn test_htsjdk_dovetail_five_prime_tie_is_fr_from_both_reads() {
let (header, records) = pair(100, "100M", false, 1, "100M", true);
assert_eq!(fr(&header, &records), [true, true]);
assert_eq!(ends(&header, &records, 99), [Some(0), Some(0)]);
}
#[test]
fn test_htsjdk_soft_clipped_dovetail_is_fr_from_both_reads() {
let (header, records) = pair(100, "90S10M", false, 91, "10M90S", true);
assert_eq!(fr(&header, &records), [true, true]);
assert_eq!(ends(&header, &records, 99), [Some(90), Some(90)]);
}
#[test]
fn test_fgumi_coincident_five_prime_dovetail_is_fr_in_either_order() {
let (header, records) = pair(96, "68S53M8S", false, 49, "28S48M53S", true);
assert_eq!(fr(&header, &records), [true, true]);
let (header, swapped) = pair(49, "28S48M53S", true, 96, "68S53M8S", false);
assert_eq!(fr(&header, &swapped), [true, true]);
assert_eq!(ends(&header, &records, 95), [Some(53), Some(68)]);
}
#[test]
fn test_fgumi_one_past_the_five_prime_tie_is_rf() {
let (header, records) = pair(100, "100M", true, 200, "100M", false);
assert_eq!(fr(&header, &records), [false, false]);
let (header, records) = pair(101, "100M", false, 1, "100M", true);
assert_eq!(fr(&header, &records), [false, false]);
}
#[test]
fn test_fgumi_zero_reference_span_reverse_read_at_its_mates_start_is_rf() {
let (header, records) = pair(100, "100M", false, 100, "100S", true);
assert_eq!(fr(&header, &records), [false, false]);
assert_eq!(ends(&header, &records, 99), [None, None]);
}
#[test]
fn test_fgumi_extreme_coordinates_do_not_overflow() {
let long = "1M268435455N1M";
let (header, records) = pair(2_100_000_000, long, false, 2_000_000_000, long, true);
assert_eq!(fr(&header, &records), [true, true]);
let (header, records) = pair(2_147_483_647, "1M", false, 2_147_483_000, long, true);
assert_eq!(fr(&header, &records), [true, true]);
}
#[test]
fn test_the_template_length_is_never_read() {
let (header, mut records) = pair(100, "100M", false, 1, "100M", true);
for tlen in [0, -7, i32::MIN] {
for record in &mut records {
*record.template_length_mut() = tlen;
}
assert_eq!(fr(&header, &records), [true, true], "{tlen}");
}
}
#[test]
fn test_fgbio_reads_not_of_a_mapped_pair_are_not_fr() {
let mut builder = SamBuilder::new().read_length(10).base_quality(20);
let mut records = builder.add_frag(Frag::at(100));
records.extend(builder.add_pair(Pair::at(100, 100).unmapped2(true)));
assert_eq!(fr(builder.header(), &records), [false, false, false]);
}
#[test]
fn test_fgbio_pairs_on_different_contigs_are_not_fr() {
let mut builder = SamBuilder::new().read_length(10).base_quality(20);
let records: Vec<RecordBuf> = builder
.add_pair(Pair::at(100, 200))
.into_iter()
.map(|record| SamBuilder::with_mate_reference_sequence_id(record, 1))
.collect();
assert_eq!(fr(builder.header(), &records), [false, false]);
}
#[test]
fn test_fgbio_only_an_actual_fr_pair_is_fr() {
let strands = [
(Strand::Plus, Strand::Plus, false),
(Strand::Minus, Strand::Minus, false),
(Strand::Minus, Strand::Plus, false),
(Strand::Plus, Strand::Minus, true),
];
for (strand1, strand2, expected) in strands {
let mut builder = SamBuilder::new().read_length(10).base_quality(20);
let records = builder.add_pair(Pair::at(100, 200).strand1(strand1).strand2(strand2));
assert_eq!(fr(builder.header(), &records), [expected, expected]);
}
}
#[test]
fn test_not_fr_and_past_the_mates_end_are_told_apart_by_is_fr_pair() {
let (header, records) = pair(100, "50M", true, 200, "50M", false);
assert_eq!(fr(&header, &records), [false, false]);
for position in [99, 120, 148, 199, 220, 248] {
assert_eq!(
ends(&header, &records, position),
[None, None],
"{position}"
);
}
let (header, records) = pair(100, "100M", false, 60, "90M10S", true);
assert_eq!(fr(&header, &records), [true, true]);
let forward = &records[0];
let ends: Vec<Option<usize>> = [157, 158, 159]
.into_iter()
.map(|position| template_end_distance(forward, &header, position).unwrap())
.collect();
assert_eq!(ends, [Some(1), Some(0), None]);
}
#[test]
fn test_only_a_forward_read_of_an_fr_pair_needs_a_mate_cigar() {
let (header, records) = pair(100, "50M", false, 150, "50M", true);
let bare: Vec<RecordBuf> = records
.into_iter()
.map(SamBuilder::without_mate_cigar)
.collect();
let refused = is_fr_pair(&bare[0], &header);
assert!(
matches!(&refused, Err(Error::MissingMateCigar { name }) if name == "q"),
"{refused:?}"
);
assert!(is_fr_pair(&bare[1], &header).unwrap());
let (header, records) = pair(100, "50M", false, 150, "50M", false);
let tandem = SamBuilder::without_mate_cigar(records[0].clone());
assert!(!is_fr_pair(&tandem, &header).unwrap());
}
#[test]
fn test_which_reads_need_their_mates_cigar() {
let without = |records: Vec<RecordBuf>| -> Vec<RecordBuf> {
records
.into_iter()
.map(SamBuilder::without_mate_cigar)
.collect()
};
let (header, inward) = pair(100, "100M", false, 150, "100M", true);
let inward = without(inward);
assert!(matches!(
is_fr_pair(&inward[0], &header),
Err(Error::MissingMateCigar { .. })
));
assert!(is_fr_pair(&inward[1], &header).unwrap());
assert!(matches!(
template_end_distance(&inward[1], &header, 160),
Err(Error::MissingMateCigar { .. })
));
let (header, outward) = pair(500, "100M", false, 100, "100M", true);
let outward = without(outward);
assert!(matches!(
is_fr_pair(&outward[0], &header),
Err(Error::MissingMateCigar { .. })
));
assert!(!is_fr_pair(&outward[1], &header).unwrap());
assert_eq!(
template_end_distance(&outward[1], &header, 150).unwrap(),
None
);
}