use super::*;
fn random_bases(mut state: u64, len: usize) -> Vec<u8> {
(0..len)
.map(|_| {
state = state.wrapping_add(0x9e37_79b9_7f4a_7c15);
let mut z = state;
z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
z ^= z >> 31;
b"ACGT"[(z >> 62) as usize]
})
.collect()
}
fn infer_owned(reads: &[Vec<u8>]) -> Vec<InferredAdapter> {
infer_with_known(reads, Vec::new())
}
fn infer_with_known(reads: &[Vec<u8>], known: Vec<Adapter>) -> Vec<InferredAdapter> {
let sample: Vec<&[u8]> = reads.iter().map(Vec::as_slice).collect();
discover(
&sample,
&AdapterConfig {
adapters: known,
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 20,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
},
)
}
#[test]
fn recovers_three_distinct_adapters_without_length_cap() {
let adapters: Vec<Vec<u8>> = [27, 43, 71]
.into_iter()
.enumerate()
.map(|(i, len)| random_bases(313 + i as u64, len))
.collect();
let reads: Vec<Vec<u8>> = (0..900)
.map(|i| {
let mut read = adapters[i % 3].clone();
read.extend(random_bases(4321 + i as u64, 250));
read
})
.collect();
let found = infer_owned(&reads);
for seq in &adapters {
assert!(
found.iter().any(|d| d.adapter.seq == *seq),
"missing {}: {found:?}",
String::from_utf8_lossy(seq)
);
}
assert_eq!(found.len(), 3);
}
#[test]
fn recovers_minority_adapter_beside_a_dominant_family() {
let common = random_bases(47319, 31);
let rare = random_bases(18971, 43);
let reads: Vec<Vec<u8>> = (0..2000)
.map(|i| {
let mut read = match i % 100 {
0..=69 => common.clone(),
70..=74 => rare.clone(),
_ => Vec::new(),
};
read.extend(random_bases(18231 + i, 420));
read
})
.collect();
let found = infer_owned(&reads);
assert!(found.iter().any(|d| d.adapter.seq == common), "{found:?}");
assert!(found.iter().any(|d| d.adapter.seq == rare), "{found:?}");
assert_eq!(found.len(), 2, "{found:?}");
}
#[test]
fn tandem_repeat_ends_do_not_produce_adapters() {
let reads: Vec<Vec<u8>> = (0..600)
.map(|i| {
let mut read = b"TTAGGG".repeat(10);
if i % 3 == 0 {
read[19] = b'C';
}
read.extend(random_bases(87123 + i, 400));
read
})
.collect();
let found = infer_owned(&reads);
assert!(found.is_empty(), "{found:?}");
}
#[test]
fn minority_primer_uses_unprimed_insert_boundaries() {
let primer = random_bases(88971, 24);
let anchor = random_bases(34723, 140);
let reads: Vec<Vec<u8>> = (0..2000)
.map(|i| {
let mut read = if i % 20 == 0 {
primer.clone()
} else {
Vec::new()
};
read.extend_from_slice(&anchor);
read.extend(random_bases(8921 + i, 300));
read
})
.collect();
let found = infer_owned(&reads);
assert_eq!(found.len(), 1, "{found:?}");
assert_eq!(found[0].adapter.seq, primer);
}
#[test]
fn kmer_support_counts_independent_windows() {
let seed = b"ACGTCAGTGCATGACT";
let repeated = seed.repeat(5);
let windows = vec![repeated.as_slice(), seed.as_slice()];
let counts = top_kmers(&windows, 16, 500);
assert_eq!(
counts
.iter()
.find(|(key, _)| *key == encode_kmer(seed).unwrap())
.unwrap()
.1,
2
);
assert!(top_kmers(&[b"TTAGGGTTAGGGTTAGGG"], 16, 500).is_empty());
}
#[test]
fn clean_conserved_inserts_are_not_adapters() {
let prefix = random_bases(7877, 140);
let suffix = random_bases(4512, 140);
let reads: Vec<Vec<u8>> = (0..400)
.map(|i| {
let mut read = prefix.clone();
read.extend(random_bases(915 + i, 200));
read.extend_from_slice(&suffix);
read
})
.collect();
assert!(infer_owned(&reads).is_empty());
}
#[test]
fn variable_conserved_inserts_extend_beyond_assembly_windows() {
let anchors: Vec<_> = (0..4)
.map(|i| (random_bases(7877 + i, 120), random_bases(4512 + i, 120)))
.collect();
let reads: Vec<Vec<u8>> = (0..2000)
.map(|i| {
let (prefix, suffix) = &anchors[i % anchors.len()];
let mut read = prefix.clone();
read.extend(random_bases(915 + i as u64, 300));
read.extend_from_slice(suffix);
let mutations = random_bases(54371 + i as u64, read.len() * 5);
let mut mutated = Vec::new();
for (&base, event) in read.iter().zip(mutations.as_chunks::<5>().0) {
match encode_kmer(&event[..4]).unwrap() {
0..=4 => mutated.push(event[4]),
5..=6 => {},
7 => mutated.extend_from_slice(&[base, event[4]]),
_ => mutated.push(base),
}
}
mutated
})
.collect();
let found = infer_owned(&reads);
assert!(found.is_empty(), "{found:?}");
}
#[test]
fn recovers_degenerate_primers_at_conserved_insert_boundaries() {
let front = b"TCGATGARYCTACGTGACCT";
let rear = b"GCTAGTACCGATGCTAGTCA";
let prefix = random_bases(712, 140);
let suffix = random_bases(815, 140);
let reads: Vec<Vec<u8>> = (0..500usize)
.map(|i| {
let mut read = Vec::new();
if i % 5 != 0 {
read.extend_from_slice(front);
read[7] = b"AG"[(i / 5) % 2];
read[8] = b"CT"[(i / 10) % 2];
}
read.extend_from_slice(&prefix);
read.extend(random_bases(9712 + i as u64, 200));
read.extend_from_slice(&suffix);
if i % 5 != 0 {
read.extend_from_slice(rear);
}
read
})
.collect();
let found = infer_owned(&reads);
assert!(found.iter().any(|d| d.adapter.seq == front), "{found:?}");
assert!(found.iter().any(|d| d.adapter.seq == rear), "{found:?}");
assert_eq!(found.len(), 2, "{found:?}");
}
#[test]
fn ambiguity_codes_cover_exactly_the_voted_bases() {
for mask in 1..16 {
let bases = crate::adapter::search::iupac_bases(ambiguity_code(mask)).unwrap();
let actual = bases
.iter()
.fold(0usize, |m, &b| m | (1 << encode_kmer(&[b]).unwrap()));
assert_eq!(actual, mask);
}
}
#[test]
fn distinct_primers_at_one_insert_boundary_remain_distinct() {
let primers = [random_bases(7651, 22), random_bases(2157, 24)];
let insert = random_bases(2871, 140);
let reads: Vec<Vec<u8>> = (0..600)
.map(|i| {
let mut read = Vec::new();
if i % 5 != 0 {
read.extend_from_slice(&primers[i % 2]);
}
read.extend_from_slice(&insert);
read.extend(random_bases(159 + i as u64, 200));
read
})
.collect();
let found = infer_owned(&reads);
for primer in &primers {
assert!(found.iter().any(|d| d.adapter.seq == *primer), "{found:?}");
}
assert_eq!(found.len(), 2);
}
#[test]
fn truncated_insert_anchor_recovers_distinct_upstream_primers() {
let primers = [random_bases(7651, 22), random_bases(2157, 24)];
let insert = random_bases(2871, 140);
let reads: Vec<Vec<u8>> = (0..600)
.map(|i| {
let mut read = Vec::new();
if i % 5 != 0 {
read.extend_from_slice(&primers[i % 2]);
}
read.extend_from_slice(&insert);
read.truncate(WINDOW_LEN);
read
})
.collect();
let windows: Vec<&[u8]> = reads.iter().map(Vec::as_slice).collect();
let found = contrast_boundary(&insert[1..90], &windows, End::Five)
.unwrap()
.primers;
assert_eq!(found.len(), 2);
for primer in &primers {
assert!(found.contains(primer), "{found:?}");
}
}
#[test]
fn kmer_codec_roundtrips() {
let k = b"ACGTACGTACGTACGT"; let code = encode_kmer(k).unwrap();
assert_eq!(decode_kmer(code, 16), k);
}
#[test]
fn encode_rejects_non_acgt() {
assert_eq!(encode_kmer(b"ACGTN"), None);
assert_eq!(encode_kmer(b"acgt"), None); assert_eq!(encode_kmer(&[b'A'; 33]), None); }
#[test]
fn end_windows_slices_both_ends() {
let r1: &[u8] = b"AAAACCCCGGGGTTTTACGTACGT"; let r2: &[u8] = b"TTTT"; let sample: Vec<&[u8]> = vec![r1, r2, b""]; let (five, three) = end_windows(&sample, 8);
assert_eq!(five, vec![&r1[..8], r2]); assert_eq!(three, vec![&r1[16..], r2]); }
#[test]
fn end_windows_drop_windows_holding_ambiguity_codes() {
let r1: &[u8] = b"AAAANCCCGGGGTTTTACGTACGT"; let r2: &[u8] = b"acgtacgtacgtacgtacgtacgn"; let sample: Vec<&[u8]> = vec![r1, r2];
let (five, three) = end_windows(&sample, 8);
assert_eq!(five, vec![&r2[..8]]);
assert_eq!(three, vec![&r1[16..]]);
}
#[test]
fn top_kmers_ranks_planted_over_background() {
let planted = b"ACGTCAGTGCATGACT";
let mut owned: Vec<Vec<u8>> = Vec::new();
for i in 0..50u8 {
let mut wnd = planted.to_vec();
wnd.push(b'N');
wnd.extend_from_slice(&[b'B' + (i % 4), b'C', b'G', b'T']);
owned.push(wnd);
}
let windows: Vec<&[u8]> = owned.iter().map(|v| v.as_slice()).collect();
let ranked = top_kmers(&windows, 16, 500);
assert_eq!(decode_kmer(ranked[0].0, 16), planted);
assert_eq!(ranked[0].1, 50);
}
#[test]
fn top_kmers_drops_homopolymer() {
let windows: Vec<&[u8]> = vec![b"AAAAAAAAAAAAAAAA"]; assert!(
top_kmers(&windows, 16, 500).is_empty(),
"Low-complexity k-mer dropped"
);
}
#[test]
fn windows_containing_counts_windows_once_and_ignores_rc() {
use crate::adapter::search::new_searcher_fwd;
let kmer = b"AAAACCCCGGGGTATG"; let w0v = b"TTAAAACCCCGGGGTATGTT".to_vec(); let w1v = b"TTAAAACACCGGGGTATGTT".to_vec(); let mut w2v = b"AAAACCCCGGGGTATG".to_vec(); w2v.extend_from_slice(b"GGGGAAAACCCCGGGGTATG");
let w3v = b"TTCATACCCCGGGGTTTTTT".to_vec(); let windows: Vec<&[u8]> = vec![&w0v, &w1v, &w2v, &w3v];
let mut s = new_searcher_fwd();
assert_eq!(windows_containing(&mut s, kmer, &windows, 2), 3);
}
#[test]
fn bounded_heaviest_path_reconstructs_known_consensus() {
let mk = |s: &[u8], w: u32| (encode_kmer(s).unwrap(), w);
let nodes = vec![
mk(b"ACGT", 9),
mk(b"CGTA", 8),
mk(b"GTAC", 7),
mk(b"TACG", 6),
];
let (cons, profile, weight) = bounded_heaviest_path(&nodes, 4, 100).unwrap();
assert_eq!(cons, b"ACGTACG"); assert_eq!(profile.len(), cons.len());
assert_eq!(weight, 9 + 8 + 7 + 6);
}
#[test]
fn bounded_heaviest_path_terminates_on_cycle() {
let mk = |s: &[u8], w: u32| (encode_kmer(s).unwrap(), w);
let nodes = vec![mk(b"ATAT", 5), mk(b"TATA", 5)];
let (cons, _profile, _w) = bounded_heaviest_path(&nodes, 4, 12).unwrap();
assert!(cons.len() <= 12, "No loop: each node used at most once");
assert!(cons.starts_with(b"ATAT") || cons.starts_with(b"TATA"));
}
#[test]
fn peel_extracts_two_distinct_adapters() {
let mk = |s: &[u8], w: u32| (encode_kmer(s).unwrap(), w);
let nodes = vec![
mk(b"ACGT", 100),
mk(b"CGTA", 99),
mk(b"GTAC", 98),
mk(b"TTGG", 90),
mk(b"TGGT", 89),
mk(b"GGTT", 88),
];
let paths = peel_paths(nodes, 4, End::Five);
assert_eq!(paths.len(), 2);
assert!(paths[0].0.starts_with(b"ACGT"));
assert!(paths[1].0.starts_with(b"TTGG"));
}
#[test]
fn name_against_matches_catalog_entry() {
let refs = vec![Adapter {
name: "SQK-TEST".into(),
seq: b"ACGTACGTACGTACGT".to_vec(),
role: Role::Adapter,
}];
let hits = name_against(b"ACGTACGTACGTACGT", &refs, 0.2);
assert_eq!(hits[0].0, "SQK-TEST");
assert!((hits[0].1 - 100.0).abs() < 1e-3);
}
#[test]
fn name_against_requires_high_identity() {
let reference = b"GGGGTTTTGGGGTTTTGGGG";
let refs = vec![Adapter {
name: "REF".into(),
seq: reference.to_vec(),
role: Role::Adapter,
}];
let mutate = |count: usize| -> Vec<u8> {
let mut seq = reference.to_vec();
for i in 0..count {
seq[3 + 5 * i] = b'C';
}
seq
};
assert_eq!(name_against(&mutate(2), &refs, 0.2).len(), 1);
assert_eq!(name_against(&mutate(3), &refs, 0.2).len(), 1);
assert!(
name_against(&mutate(4), &refs, 0.2).is_empty(),
"80 percent identity is below the naming floor"
);
}
#[test]
fn discovered_adapters_are_named_by_order_with_catalog_annotation() {
let adapter: &[u8] = b"AATGTACTTCGTTCAGTTACGTATTGCT";
let mut owned: Vec<Vec<u8>> = Vec::new();
for i in 0..300usize {
let mut read = adapter.to_vec();
let mut state = 0x9E37_79B9_7F4A_7C15u64.wrapping_add(i as u64);
for _ in 0..120usize {
state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^= z >> 31;
read.push(b"ACGT"[((z >> 62) & 0b11) as usize]);
}
owned.push(read);
}
let sample: Vec<&[u8]> = owned.iter().map(|v| v.as_slice()).collect();
let base = AdapterConfig {
adapters: vec![],
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 1,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
let found = discover(&sample, &base);
assert!(!found.is_empty(), "The planted adapter is discovered");
for (i, d) in found.iter().enumerate() {
assert_eq!(d.adapter.name, format!("inferred_{}", i + 1));
}
assert_eq!(
found[0].name_hits.first().map(|(name, _)| name.as_str()),
Some("LSK109_front"),
"The catalog match is an annotation: {:?}",
found[0].name_hits
);
}
#[test]
fn discover_finds_nothing_in_ambiguity_runs() {
let mut owned: Vec<Vec<u8>> = Vec::new();
for i in 0..200usize {
let mut read = vec![b'N'; 60];
let mut state = 0x9E37_79B9_7F4A_7C15u64.wrapping_add(i as u64);
for _ in 0..100usize {
state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^= z >> 31;
read.push(b"ACGT"[((z >> 62) & 0b11) as usize]);
}
owned.push(read);
}
let sample: Vec<&[u8]> = owned.iter().map(|v| v.as_slice()).collect();
let base = AdapterConfig {
adapters: vec![],
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 1,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
let found = discover(&sample, &base);
assert!(
found.is_empty(),
"An N run is not adapter evidence (got {found:?})"
);
}
#[test]
fn discover_recovers_planted_adapter_under_error() {
let adapter: &[u8] = b"AATGTACTTCGTTCAGTTACGTATTGCT"; let mut owned: Vec<Vec<u8>> = Vec::new();
for i in 0..500usize {
let mut read = adapter.to_vec();
let mut state = 0x9E37_79B9_7F4A_7C15u64.wrapping_add(i as u64);
for _ in 0..120usize {
state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^= z >> 31;
read.push(b"ACGT"[((z >> 62) & 0b11) as usize]);
}
for p in (0..adapter.len()).step_by(10) {
let q = (p + i) % adapter.len();
read[q] = b"ACGT"[(read[q] as usize + 1) % 4];
}
owned.push(read);
}
let sample: Vec<&[u8]> = owned.iter().map(|v| v.as_slice()).collect();
let base = AdapterConfig {
adapters: vec![],
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 1,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
let found = discover(&sample, &base);
assert!(!found.is_empty(), "At least one adapter discovered");
let top = &found[0];
assert!(top.adapter.seq.len() >= MIN_PATTERN_LEN);
let mut s = new_ambiguous_searcher();
let k = (0.25 * adapter.len() as f64).ceil() as usize;
assert!(
!hits(&mut s, &top.adapter.seq, adapter, k).is_empty()
|| !hits(&mut s, adapter, &top.adapter.seq, k).is_empty(),
"Recovered adapter is within 25% edit distance of the planted one"
);
}
#[test]
fn discover_dual_end_adapter_gets_max_support() {
let adapter: &[u8] = b"AATGTACTTCGTTCAGTTACGTATTGCT"; let rc: Vec<u8> = adapter
.iter()
.rev()
.map(|&b| match b {
b'A' => b'T',
b'C' => b'G',
b'G' => b'C',
b'T' => b'A',
_ => unreachable!("Adapter is pure ACGT"),
})
.collect();
let mut owned: Vec<Vec<u8>> = Vec::new();
for i in 0..200usize {
let mut read = adapter.to_vec();
for p in (0..adapter.len()).step_by(6) {
let q = (p + i) % adapter.len();
read[q] = b"ACGT"[(read[q] as usize + 1) % 4];
}
let mut state = 0x9E37_79B9_7F4A_7C15u64.wrapping_add(i as u64);
for _ in 0..150usize {
state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^= z >> 31;
read.push(b"ACGT"[((z >> 62) & 0b11) as usize]);
}
read.extend_from_slice(&rc);
owned.push(read);
}
let sample: Vec<&[u8]> = owned.iter().map(|v| v.as_slice()).collect();
let base = AdapterConfig {
adapters: vec![],
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 1,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
let found = discover(&sample, &base);
let mut s = new_ambiguous_searcher();
let k = (0.25 * adapter.len() as f64).ceil() as usize;
let near: Vec<&InferredAdapter> = found
.iter()
.filter(|d| {
!hits(&mut s, &d.adapter.seq, adapter, k).is_empty()
|| !hits(&mut s, adapter, &d.adapter.seq, k).is_empty()
})
.collect();
assert_eq!(
near.len(),
1,
"The shared 5'/3' adapter is discovered as a single entry: {found:?}"
);
assert!(
near[0].support > 0.7,
"Merged adapter's support ({}) must reflect the max across ends \
(the 3' end recovers at about 1.0), not the weaker 5' end alone (about 0.18)",
near[0].support
);
}
#[test]
fn discover_finds_nothing_in_clean_reads() {
let mut owned: Vec<Vec<u8>> = Vec::new();
for i in 0..300usize {
let mut read = Vec::new();
let mut state = 0x9E37_79B9_7F4A_7C15u64.wrapping_add(i as u64);
for _ in 0..200usize {
state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^= z >> 31;
read.push(b"ACGT"[((z >> 62) & 0b11) as usize]);
}
owned.push(read);
}
let sample: Vec<&[u8]> = owned.iter().map(|v| v.as_slice()).collect();
let base = AdapterConfig {
adapters: vec![],
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 1,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
let found = discover(&sample, &base);
assert!(
found.is_empty(),
"No spurious adapter in clean reads (got {found:?})"
);
}
#[test]
fn stride_sample_is_identity_when_within_cap() {
let a: &[u8] = b"A";
let b: &[u8] = b"C";
let c: &[u8] = b"G";
let windows: Vec<&[u8]> = vec![a, b, c];
assert_eq!(stride_sample(&windows, 4), windows);
}
#[test]
fn stride_sample_spans_the_whole_range_not_just_a_prefix() {
let bytes: Vec<u8> = (0..13u8).map(|i| b'A' + i).collect();
let windows: Vec<&[u8]> = bytes.iter().map(std::slice::from_ref).collect();
let sampled = stride_sample(&windows, 4);
assert!(sampled.len() <= 4);
assert_eq!(
sampled,
vec![windows[0], windows[4], windows[8], windows[12]]
);
let last_idx = 12usize; assert!(
last_idx >= (13usize * 2).div_ceil(3),
"Last sampled window must fall in the last third of the range, not a prefix"
);
assert_eq!(*sampled.last().unwrap(), windows[last_idx]);
}
#[test]
#[ignore]
fn discover_is_not_order_biased_by_recount_window_cap() {
let adapter: &[u8] = b"AATGTACTTCGTTCAGTTACGTATTGCT"; let n_clean = RECOUNT_WINDOWS + 1;
let n_planted = RECOUNT_WINDOWS;
let splitmix_tail = |i: usize, len: usize| -> Vec<u8> {
let mut state = 0x9E37_79B9_7F4A_7C15u64.wrapping_add(i as u64);
let mut out = Vec::with_capacity(len);
for _ in 0..len {
state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^= z >> 31;
out.push(b"ACGT"[((z >> 62) & 0b11) as usize]);
}
out
};
let mut owned: Vec<Vec<u8>> = Vec::with_capacity(n_clean + n_planted);
for i in 0..n_clean {
owned.push(splitmix_tail(i, 40)); }
for i in 0..n_planted {
let mut read = adapter.to_vec();
read.extend(splitmix_tail(n_clean + i, 12));
owned.push(read);
}
let sample: Vec<&[u8]> = owned.iter().map(|v| v.as_slice()).collect();
let base = AdapterConfig {
adapters: vec![],
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 1,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
let found = discover(&sample, &base);
assert!(
!found.is_empty(),
"Adapter present in a clear majority of reads after the first \
RECOUNT_WINDOWS must be discovered (got {found:?})"
);
let mut s = new_ambiguous_searcher();
let k = (0.25 * adapter.len() as f64).ceil() as usize;
assert!(
found.iter().any(|d| {
!hits(&mut s, &d.adapter.seq, adapter, k).is_empty()
|| !hits(&mut s, adapter, &d.adapter.seq, k).is_empty()
}),
"Discovered adapters must include one within 25% edit distance \
of the planted adapter: {found:?}"
);
}
#[test]
fn discover_recovers_planted_adapter_from_lowercase_reads() {
let adapter: &[u8] = b"AATGTACTTCGTTCAGTTACGTATTGCT"; let mut owned: Vec<Vec<u8>> = Vec::new();
for i in 0..500usize {
let mut read = adapter.to_vec();
let mut state = 0x9E37_79B9_7F4A_7C15u64.wrapping_add(i as u64);
for _ in 0..120usize {
state = state.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = state;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^= z >> 31;
read.push(b"ACGT"[((z >> 62) & 0b11) as usize]);
}
let lower: Vec<u8> = read.iter().map(u8::to_ascii_lowercase).collect();
owned.push(lower);
}
let sample: Vec<&[u8]> = owned.iter().map(|v| v.as_slice()).collect();
let base = AdapterConfig {
adapters: vec![],
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 1,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
let found = discover(&sample, &base);
assert!(
!found.is_empty(),
"Lowercase reads must be inferable (got {found:?})"
);
let top = &found[0];
let mut s = new_ambiguous_searcher();
let k = (0.25 * adapter.len() as f64).ceil() as usize;
assert!(
!hits(&mut s, &top.adapter.seq, adapter, k).is_empty()
|| !hits(&mut s, adapter, &top.adapter.seq, k).is_empty(),
"Discovered adapter (seq {:?}) must be within 25% edit distance \
of the uppercase planted adapter",
String::from_utf8_lossy(&top.adapter.seq)
);
assert!(
top.adapter.seq.iter().all(u8::is_ascii_uppercase),
"Discovered sequence must be uppercase: {:?}",
String::from_utf8_lossy(&top.adapter.seq)
);
}
fn rc(seq: &[u8]) -> Vec<u8> {
crate::adapter::reverse_complement(seq)
}
fn contains(hay: &[u8], needle: &[u8]) -> bool {
needle.len() <= hay.len() && hay.windows(needle.len()).any(|w| w == needle)
}
#[test]
fn known_adapter_precedes_a_discovered_primer_layer() {
let adapter = random_bases(5011, 30);
let primer = random_bases(5023, 22);
let reads: Vec<Vec<u8>> = (0..600)
.map(|i| {
let mut read = adapter.clone();
read.extend_from_slice(&primer);
read.extend(random_bases(7000 + i, 400));
read
})
.collect();
let known = vec![Adapter {
name: "known".into(),
seq: adapter.clone(),
role: Role::Adapter,
}];
let found = infer_with_known(&reads, known);
assert_eq!(found.len(), 1, "{found:?}");
assert_eq!(found[0].adapter.seq, primer);
assert_eq!(found[0].adapter.role, Role::Primer);
assert_eq!(found[0].layer, 0);
}
#[test]
fn discovers_barcode_layer_between_flanks() {
let adapter = random_bases(6011, 30);
let flank1 = random_bases(6023, 16);
let flank2 = random_bases(6031, 32);
let barcodes: Vec<Vec<u8>> = (0..8).map(|i| random_bases(6100 + i, 24)).collect();
let reads: Vec<Vec<u8>> = (0..1600)
.map(|i| {
let mut read = adapter.clone();
read.extend_from_slice(&flank1);
read.extend_from_slice(&barcodes[i % 8]);
read.extend_from_slice(&flank2);
read.extend(random_bases(9000 + i as u64, 400));
read
})
.collect();
let found = infer_owned(&reads);
for d in &found {
let technical = barcodes.iter().any(|b| {
contains(
&[&adapter[..], &flank1, b, &flank2].concat(),
&d.adapter.seq,
)
});
assert!(technical, "{:?}", String::from_utf8_lossy(&d.adapter.seq));
let expected = if contains(&d.adapter.seq, &adapter[..16]) {
Role::Adapter
} else if barcodes.iter().any(|b| contains(&d.adapter.seq, &b[4..20])) {
Role::Barcode
} else {
Role::Primer
};
assert_eq!(d.adapter.role, expected, "{d:?}");
}
assert!(
found
.iter()
.any(|d| d.layer == 0 && contains(&d.adapter.seq, &adapter[..16]))
);
assert!(
found
.iter()
.any(|d| d.layer > 0 && contains(&d.adapter.seq, &flank2)),
"{found:?}"
);
let recovered = barcodes
.iter()
.filter(|b| {
found
.iter()
.any(|d| d.adapter.role == Role::Barcode && contains(&d.adapter.seq, &b[4..20]))
})
.count();
assert!(recovered >= 6, "{recovered} barcodes recovered: {found:?}");
let cfg = AdapterConfig {
adapters: found.into_iter().map(|d| d.adapter).collect(),
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 20,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
for read in reads.iter().take(16) {
let segments = crate::adapter::adapter_segments(read, &cfg);
assert_eq!(segments, vec![(102, read.len())], "{segments:?}");
}
}
#[test]
fn eroded_short_barcodes_end_at_the_insert_boundary() {
let barcodes: Vec<Vec<u8>> = (0..12).map(|i| random_bases(8100 + i, 16)).collect();
let reads: Vec<Vec<u8>> = (0..2400)
.map(|i| {
let barcode = &barcodes[i % 12];
let mut read = barcode[(i / 12) % 2..].to_vec();
read.extend(random_bases(12000 + i as u64, 400));
read
})
.collect();
let found = infer_owned(&reads);
for d in &found {
assert!(
barcodes.iter().any(|b| contains(b, &d.adapter.seq)),
"{:?}",
String::from_utf8_lossy(&d.adapter.seq)
);
}
let recovered = barcodes
.iter()
.filter(|b| found.iter().any(|d| contains(&d.adapter.seq, &b[1..])))
.count();
assert!(recovered >= 10, "{recovered} barcodes recovered: {found:?}");
}
#[test]
fn conservation_is_judged_against_the_background_composition() {
let uniform = [0.25; 4];
let at_rich = [0.4, 0.1, 0.1, 0.4];
assert!(conserved([97, 1, 1, 1], uniform));
assert!(conserved([3, 90, 3, 4], at_rich));
assert!(
conserved([1, 48, 1, 50], uniform),
"two-fold degenerate base"
);
assert!(
conserved([1, 48, 1, 50], at_rich),
"two-fold degenerate base"
);
assert!(!conserved([25, 25, 25, 25], uniform));
assert!(!conserved([30, 20, 20, 30], uniform));
assert!(!conserved([40, 10, 10, 40], at_rich));
assert!(!conserved([47, 8, 5, 40], at_rich));
}
fn at_rich_bases(seed: u64, len: usize) -> Vec<u8> {
let first = random_bases(seed ^ 0x5555, len);
let second = random_bases(seed ^ 0xAAAA, len);
random_bases(seed, len)
.into_iter()
.zip(first.into_iter().zip(second))
.map(|(base, draws)| match (base, draws) {
(b'C' | b'G', (b'A' | b'G' | b'T', b'A' | b'G')) => b'A',
(b'C' | b'G', (b'A' | b'G' | b'T', b'T')) => b'T',
_ => base,
})
.collect()
}
#[test]
fn eroded_short_barcodes_end_at_an_at_rich_insert_boundary() {
let barcodes: Vec<Vec<u8>> = (0..12).map(|i| random_bases(8300 + i, 16)).collect();
let reads: Vec<Vec<u8>> = (0..2400)
.map(|i| {
let barcode = &barcodes[i % 12];
let mut read = barcode[(i / 12) % 2..].to_vec();
read.extend(at_rich_bases(14000 + i as u64, 400));
read
})
.collect();
let found = infer_owned(&reads);
for d in &found {
assert!(
barcodes.iter().any(|b| contains(b, &d.adapter.seq)),
"{:?}",
String::from_utf8_lossy(&d.adapter.seq)
);
}
let recovered = barcodes
.iter()
.filter(|b| found.iter().any(|d| contains(&d.adapter.seq, &b[1..])))
.count();
assert!(recovered >= 10, "{recovered} barcodes recovered: {found:?}");
}
#[test]
fn conserved_insert_mirrored_at_truncated_read_ends_is_excluded() {
let adapter = random_bases(7011, 30);
let primer = random_bases(7023, 20);
let conserved = random_bases(7031, 40);
let reads: Vec<Vec<u8>> = (0..800)
.map(|i| {
let mut read = adapter.clone();
read.extend_from_slice(&primer);
read.extend_from_slice(&conserved);
read.extend(random_bases(11000 + i as u64, 300));
read.extend(rc(&conserved));
read.extend_from_slice(&rc(&primer)[..7]);
read
})
.collect();
let found = infer_owned(&reads);
assert!(!found.is_empty());
let technical = [&adapter[..], &primer].concat();
for d in &found {
assert!(
contains(&technical, &d.adapter.seq),
"{:?}",
String::from_utf8_lossy(&d.adapter.seq)
);
}
assert!(
found.iter().any(|d| contains(&d.adapter.seq, &adapter)),
"{found:?}"
);
}
#[test]
fn barcode_construct_names_no_inferred_sequence() {
let construct = Adapter {
name: "NB_construct".into(),
seq: b"ATTGCTAAGGTTAANNNNNNNNNNNNNNNNNNNNNNNNCAGCACCT".to_vec(),
role: Role::Barcode,
};
assert!(name_against(b"TGACTCCTCGCTTTCGA", &[construct], 0.15).is_empty());
}
#[test]
fn windows_covered_requires_the_whole_pattern() {
let shared = b"ATCTCTCTCAACAACAACAACGGAGGAGGAGGAAAAGAGAGAGAT";
let mut pattern = shared.to_vec();
pattern.extend_from_slice(b"TACGGCTACCTTGTTACGACTT");
let mut other = shared.to_vec();
other.extend_from_slice(b"AGAGTTTGATCCTGGCTCAGTTACCGATGG");
let mut own = pattern.clone();
own.extend_from_slice(b"GGATCCATTAC");
let mut searcher = crate::adapter::search::new_searcher_fwd();
let k = crate::adapter::edit_budget(0.2, pattern.len());
let covered = windows_covered(&mut searcher, &pattern, &[&other, &own], k);
assert_eq!(covered, [false, true]);
}
fn draw(state: &mut u64) -> u64 {
*state = state.wrapping_add(0x9e37_79b9_7f4a_7c15);
let mut z = *state;
z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
z ^ (z >> 31)
}
fn with_errors(seq: &[u8], seed: u64, per_mille: u64) -> Vec<u8> {
let mut state = seed;
let mut out = Vec::with_capacity(seq.len() + 8);
for &base in seq {
let roll = draw(&mut state) % 3000;
let pick = b"ACGT"[(draw(&mut state) % 4) as usize];
if roll < per_mille {
out.push(if pick == base {
b"ACGT"[(pick as usize + 1) % 4]
} else {
pick
});
} else if roll < 2 * per_mille {
} else if roll < 3 * per_mille {
out.extend_from_slice(&[base, pick]);
} else {
out.push(base);
}
}
out
}
fn strand_primer_reads() -> (Vec<Vec<u8>>, Vec<u8>, Vec<u8>, Vec<u8>) {
let outer = random_bases(8101, 45);
let core = random_bases(8111, 40);
let forward = random_bases(8121, 25);
let reverse = random_bases(8131, 30);
let reads = (0..1500u64)
.map(|i| {
let mut state = 30_000 + i;
let mut erosion = 0;
while erosion < 30 && !draw(&mut state).is_multiple_of(5) {
erosion += 1;
}
let mut read = with_errors(&outer[erosion..], 40_000 + i, 120);
let mut rest = core.clone();
rest.extend_from_slice(&forward);
rest.extend(random_bases(20_000 + i, 400));
rest.extend(std::iter::repeat_n(b'A', 12 + (i % 9) as usize));
rest.extend(rc(&reverse));
rest.extend(rc(&core));
read.extend(with_errors(&rest, 50_000 + i, 30));
read.extend(with_errors(
&rc(&outer)[..5 + (i % 7) as usize],
60_000 + i,
120,
));
if i % 2 == 1 { rc(&read) } else { read }
})
.collect();
(reads, core, forward, reverse)
}
#[test]
fn shared_core_divides_into_strand_primers() {
let (reads, core, forward, reverse) = strand_primer_reads();
let found = infer_owned(&reads);
let seqs: Vec<Vec<u8>> = found.iter().map(|d| d.adapter.seq.clone()).collect();
let overlap = |part: &[u8], seq: &[u8]| {
longest_common_substring(part, seq).max(longest_common_substring(part, &rc(seq)))
};
for (part, least) in [(&core, 30), (&forward, 22), (&reverse, 25)] {
assert!(
seqs.iter().any(|s| overlap(part, s) >= least),
"{:?}",
String::from_utf8_lossy(part)
);
}
for s in &seqs {
assert!(
!contains(s, b"TTTTTTTT") && !contains(s, b"AAAAAAAA"),
"{:?}",
String::from_utf8_lossy(s)
);
}
}
#[test]
fn division_needs_continuations_that_do_not_rejoin() {
let shared = random_bases(8201, 30);
let left = random_bases(8211, 40);
let right = random_bases(8221, 40);
let tail = random_bases(8231, 40);
let mut windows: Vec<Vec<u8>> = Vec::new();
for i in 0..200 {
let mut divided = shared.clone();
divided.extend_from_slice(if i % 2 == 0 { &left } else { &right });
windows.push(divided);
let mut bubble = shared.clone();
bubble.push(if i % 2 == 0 { b'A' } else { b'C' });
bubble.extend_from_slice(&tail);
windows.push(bubble);
}
let (divided, bubbled): (Vec<&[u8]>, Vec<&[u8]>) = (
windows.iter().step_by(2).map(Vec::as_slice).collect(),
windows
.iter()
.skip(1)
.step_by(2)
.map(Vec::as_slice)
.collect(),
);
let mut cons = shared.clone();
cons.extend_from_slice(&left);
let counts = kmer_counts(÷d);
let edge = division_point(&cons, &counts, divided.len(), 0, cons.len(), End::Five);
assert_eq!(edge.map(|(edge, _)| edge), Some(shared.len()));
let mut cons = shared.clone();
cons.push(b'A');
cons.extend_from_slice(&tail);
let counts = kmer_counts(&bubbled);
assert!(division_point(&cons, &counts, bubbled.len(), 0, cons.len(), End::Five).is_none());
}
#[test]
fn inner_run_measures_the_insert_facing_homopolymer() {
assert_eq!(inner_run(b"ACGTTTTTT", End::Five), 6);
assert_eq!(inner_run(b"AAAAACGT", End::Three), 5);
assert_eq!(inner_run(b"ACGT", End::Five), 1);
}
fn random_tag(state: &mut u64) -> Vec<u8> {
let mut tag = Vec::new();
for block in 0..4 {
for _ in 0..4 {
tag.push(b"ACG"[(draw(state) % 3) as usize]);
}
tag.extend_from_slice(if block == 3 { b"TTT" } else { b"TT" });
}
tag
}
fn tag_and_ggg(i: u64) -> Vec<u8> {
let mut state = 90_000 + i;
let mut tail = random_tag(&mut state);
tail.extend_from_slice(b"GGG");
tail
}
fn primed_reads(behind: impl Fn(u64) -> Vec<u8>, per_mille: u64) -> (Vec<Vec<u8>>, Vec<u8>) {
let mut head = random_bases(9101, 30);
head.extend(random_bases(9111, 24));
let reads = (0..2000u64)
.map(|i| {
let mut read = head.clone();
read.extend(behind(i));
read.extend(random_bases(70_000 + i, 400));
let read = with_errors(&read, 80_000 + i, per_mille);
if i % 2 == 1 { rc(&read) } else { read }
})
.collect();
(reads, head)
}
fn oriented_windows(reads: &[Vec<u8>]) -> Vec<Vec<u8>> {
reads
.iter()
.flat_map(|read| {
let n = read.len().min(MIRROR_WINDOW);
[read[..n].to_vec(), rc(&read[read.len() - n..])]
})
.collect()
}
fn layer_behind_primer(reads: &[Vec<u8>], head: &[u8]) -> Option<(Vec<u8>, usize)> {
let windows = oriented_windows(reads);
let windows: Vec<&[u8]> = windows.iter().map(Vec::as_slice).collect();
degenerate_layer(
&mut crate::adapter::search::new_searcher_fwd(),
&head[30..],
&windows,
base_composition(&windows),
0.2,
)
}
#[test]
fn random_tag_behind_a_primer_is_a_degenerate_layer() {
let (reads, head) = primed_reads(tag_and_ggg, 10);
let (layer, present) = layer_behind_primer(&reads, &head).expect("degenerate layer");
assert_eq!(layer, b"VVVVTTVVVVTTVVVVTTVVVVTTT");
assert!(present >= 1800, "{present}");
}
#[test]
fn discovery_trims_a_random_tag_behind_a_primer() {
let (reads, head) = primed_reads(tag_and_ggg, 10);
let found = infer_owned(&reads);
let tag = b"VVVVTTVVVVTTVVVVTTVVVVTTT";
let layer = found
.iter()
.find(|d| d.adapter.seq == tag || d.adapter.seq == rc(tag))
.unwrap_or_else(|| panic!("{found:?}"));
assert_eq!(layer.adapter.role, Role::Primer);
let cfg = AdapterConfig {
adapters: found.into_iter().map(|d| d.adapter).collect(),
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 20,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
};
for i in 0..16u64 {
let mut read = head.clone();
let tagged = read.len() + tag.len();
read.extend(tag_and_ggg(i));
read.extend(random_bases(70_000 + i, 400));
let segments = crate::adapter::adapter_segments(&read, &cfg);
assert_eq!(segments, vec![(tagged, read.len())], "{segments:?}");
let reverse = rc(&read);
let segments = crate::adapter::adapter_segments(&reverse, &cfg);
assert_eq!(segments, vec![(0, reverse.len() - tagged)], "{segments:?}");
}
let mut state = 1;
let mut read = random_bases(71_000, 600);
read.extend(random_tag(&mut state));
read.extend(random_bases(72_000, 600));
assert_eq!(
crate::adapter::adapter_segments(&read, &cfg),
vec![(0, read.len())]
);
}
#[test]
fn random_tag_behind_a_known_primer() {
let (reads, head) = primed_reads(tag_and_ggg, 10);
let known = |seq: &[u8], role| Adapter {
name: "known".into(),
seq: seq.to_vec(),
role,
};
let tag = b"VVVVTTVVVVTTVVVVTTVVVVTTT";
let found = infer_with_known(&reads, vec![known(&head, Role::Adapter)]);
let layer = found
.iter()
.find(|d| d.adapter.seq == tag || d.adapter.seq == rc(tag))
.unwrap_or_else(|| panic!("{found:?}"));
assert_eq!(layer.layer, 0);
let found = infer_with_known(
&reads,
vec![
known(&head, Role::Adapter),
known(b"TTTVVVVTTVVVVTTVVVVTTVVVVTTT", Role::Primer),
],
);
assert!(
found.iter().all(|d| is_plain_acgt(&d.adapter.seq)),
"{found:?}"
);
}
#[test]
fn conserved_or_biased_sequence_behind_a_primer_is_not_a_degenerate_layer() {
let species: Vec<Vec<u8>> = (0..6).map(|i| random_bases(9200 + i, 60)).collect();
let alternatives = [random_bases(9301, 40), random_bases(9311, 40)];
type Behind<'a> = Box<dyn Fn(u64) -> Vec<u8> + 'a>;
let cases: [(&str, Behind); 4] = [
("random insert", Box::new(|_| Vec::new())),
(
"AT-rich insert",
Box::new(|i| at_rich_bases(95_000 + i, 60)),
),
("species", Box::new(|i| species[(i % 6) as usize].clone())),
(
"alternative primers",
Box::new(|i| alternatives[(i % 2) as usize].clone()),
),
];
for (name, behind) in cases {
let (reads, head) = primed_reads(behind, 10);
let found = layer_behind_primer(&reads, &head);
assert!(found.is_none(), "{name}: {found:?}");
}
}
#[test]
fn discovery_adds_no_degenerate_layer_before_an_at_rich_insert() {
let (reads, _) = primed_reads(|i| at_rich_bases(95_000 + i, 60), 10);
let found = infer_owned(&reads);
for d in &found {
assert!(
is_plain_acgt(&d.adapter.seq),
"{:?}",
String::from_utf8_lossy(&d.adapter.seq)
);
}
}
fn trimming_with(found: Vec<InferredAdapter>) -> AdapterConfig {
AdapterConfig {
adapters: found.into_iter().map(|d| d.adapter).collect(),
error_rate: 0.2,
end_size: 150,
split: true,
min_piece: 20,
candidate_index: std::sync::OnceLock::new(),
amplicon: false,
}
}
fn two_form_reads() -> (Vec<Vec<u8>>, Vec<u8>, Vec<u8>) {
let front = random_bases(9401, 28);
let rear = rc(&front[5..27]);
let reads = (0..1500u64)
.map(|i| {
let mut read = front[(i % 3) as usize..].to_vec();
read.extend(random_bases(96_000 + i, 1200));
read.extend_from_slice(&rear[..rear.len() - (i % 4) as usize]);
with_errors(&read, 97_000 + i, 20)
})
.collect();
(reads, front, rear)
}
#[test]
fn each_end_keeps_its_own_form_of_a_shared_adapter() {
let (reads, front, rear) = two_form_reads();
let cfg = trimming_with(infer_owned(&reads));
for (seed, junction) in (0..16).map(|seed| (seed, if seed % 2 == 0 { &front } else { &rear })) {
let left = random_bases(98_001 + seed, 6000);
let right = random_bases(98_101 + seed, 6000);
let mut read = front.clone();
read.extend_from_slice(&left);
read.extend_from_slice(junction);
read.extend_from_slice(&right);
read.extend_from_slice(&rear);
let segments = crate::adapter::adapter_segments(&read, &cfg);
assert_eq!(segments.len(), 2, "{segments:?} {:?}", cfg.adapters);
let cut = front.len() + left.len();
let rejoin = cut + junction.len();
assert!(
segments[0].1.abs_diff(cut) <= 3 && segments[1].0.abs_diff(rejoin) <= 6,
"{segments:?}"
);
}
}
fn amplicon_reads() -> Vec<Vec<u8>> {
(0..1500u64)
.map(|i| {
let mut read = b"AGAGTTTGATCCTGGCTCAG"[(i % 3) as usize..].to_vec();
read.extend(random_bases(99_000 + i, 1400));
read.extend_from_slice(b"AAGTCGTAACAAGGTAACCGTA");
let read = with_errors(&read, 99_500 + i, 20);
if i % 2 == 1 { rc(&read) } else { read }
})
.collect()
}
#[test]
fn discovered_marker_primers_split_only_beside_a_partner() {
let found = infer_owned(&licon_reads());
let markers: Vec<&InferredAdapter> = found
.iter()
.filter(|d| crate::adapter::matches_marker_primer(&d.adapter.seq, 0.2))
.collect();
assert_eq!(markers.len(), 2, "{found:?}");
assert!(
markers.iter().all(|d| d.adapter.role == Role::Primer),
"{found:?}"
);
let cfg = trimming_with(found);
let (left, right) = (random_bases(99_901, 1500), random_bases(99_902, 1500));
let mut site = left.clone();
site.extend_from_slice(b"AGAGTTTGATCCTGGCTCAG");
site.extend_from_slice(&right);
assert_eq!(
crate::adapter::adapter_segments(&site, &cfg),
vec![(0, site.len())]
);
let mut junction = left.clone();
junction.extend_from_slice(b"AAGTCGTAACAAGGTAACCGTA");
junction.extend_from_slice(b"AGAGTTTGATCCTGGCTCAG");
junction.extend_from_slice(&right);
assert_eq!(
crate::adapter::adapter_segments(&junction, &cfg).len(),
2,
"{:?}",
crate::adapter::adapter_segments(&junction, &cfg)
);
}
fn hairpin_three_windows(hairpin: &[u8]) -> Vec<Vec<u8>> {
(0..600u64)
.map(|i| {
let mut window = random_bases(9600 + i, 150);
window.extend_from_slice(&hairpin[..hairpin.len() - (i % 8) as usize]);
with_errors(&window, 9700 + i, 20)
})
.collect()
}
#[test]
fn other_end_keeps_a_form_the_accepted_sequence_does_not_trim() {
let hairpin = random_bases(9501, 45);
let windows = hairpin_three_windows(&hairpin);
let windows: Vec<&[u8]> = windows.iter().map(Vec::as_slice).collect();
let base = trimming_with(Vec::new());
let accepted = hairpin[10..].to_vec();
let own = hairpin[..38].to_vec();
let candidates = vec![(own.clone(), 0.9, 1000, End::Three)];
let found = untrimmed_other_end(&accepted, End::Five, &candidates, &windows, &base);
assert_eq!(found, Some((own, 0.9, End::Three)));
let covered = hairpin[12..38].to_vec();
let candidates = vec![(covered, 0.9, 1000, End::Three)];
assert!(untrimmed_other_end(&accepted, End::Five, &candidates, &windows, &base).is_none());
}
fn with_lineage(seq: &[u8], sites: &[usize], lineage: u64) -> Vec<u8> {
let mut out = seq.to_vec();
for (bit, &site) in sites.iter().enumerate() {
if (lineage >> (bit % 4)) & 1 == 1 {
out[site] = b"CGTA"[encode_kmer(&out[site..=site]).unwrap() as usize];
}
}
out
}
fn community_templates() -> Vec<Vec<u8>> {
let start = random_bases(61_001, 30);
let end = random_bases(61_002, 30);
(0..16u64)
.map(|lineage| {
let mut template = with_lineage(&start, &[0, 3, 11, 19, 26], lineage);
template.extend(random_bases(61_100 + lineage, 1200));
template.extend(with_lineage(&end, &[4, 10, 18, 27, 29], lineage));
template
})
.collect()
}
fn community_amplicon_reads() -> (Vec<Vec<u8>>, Vec<u8>, Vec<u8>) {
let mut forward = random_bases(61_011, 20);
forward[8] = b'Y';
let mut reverse = random_bases(61_012, 22);
reverse[10] = b'R';
let templates = community_templates();
let mut state = 61_500u64;
let reads = (0..2400u64)
.map(|i| {
let mut molecule = forward.clone();
molecule[8] = b"CT"[(draw(&mut state) % 2) as usize];
molecule.extend_from_slice(&templates[(i % 16) as usize]);
let mut back = reverse.clone();
back[10] = b"AG"[(draw(&mut state) % 2) as usize];
molecule.extend(rc(&back));
let read = if (i / 16) % 2 == 1 {
rc(&molecule)
} else {
molecule
};
with_errors(&read[(draw(&mut state) % 4) as usize..], 62_000 + i, 20)
})
.collect();
(reads, forward, reverse)
}
fn iupac_compatible(seq: &[u8], pattern: &[u8]) -> bool {
let bases = |c| crate::adapter::search::iupac_bases(c).unwrap_or(&[]);
seq.len() == pattern.len()
&& seq
.iter()
.zip(pattern)
.all(|(&s, &p)| bases(s).iter().all(|b| bases(p).contains(b)))
}
fn ends_at_primer(seq: &[u8], primer: &[u8]) -> bool {
[seq.to_vec(), rc(seq)]
.iter()
.any(|s| s.len() <= primer.len() && iupac_compatible(s, &primer[primer.len() - s.len()..]))
}
#[test]
fn amplicon_primers_end_where_the_templates_begin() {
let (reads, forward, reverse) = community_amplicon_reads();
let found = infer_owned(&reads);
for d in &found {
assert!(
ends_at_primer(&d.adapter.seq, &forward) || ends_at_primer(&d.adapter.seq, &reverse),
"{} is not a primer: {found:?}",
String::from_utf8_lossy(&d.adapter.seq)
);
}
for primer in [&forward, &reverse] {
assert!(
found.iter().any(|d| d.adapter.seq.len() >= MIN_PATTERN_LEN
&& ends_at_primer(&d.adapter.seq, primer)),
"{} not found: {found:?}",
String::from_utf8_lossy(primer)
);
}
let cfg = trimming_with(found);
for (lineage, template) in community_templates().iter().enumerate() {
let mut molecule = forward.clone();
molecule[8] = b"CT"[lineage % 2];
molecule.extend_from_slice(template);
let mut back = reverse.clone();
back[10] = b'A';
molecule.extend(rc(&back));
assert_eq!(
crate::adapter::adapter_segments(&molecule, &cfg),
vec![(forward.len(), forward.len() + template.len())],
"template {lineage}"
);
}
}
#[test]
fn known_amplicon_primers_leave_nothing_to_discover() {
let (reads, forward, reverse) = community_amplicon_reads();
let known = [forward, reverse]
.into_iter()
.enumerate()
.map(|(i, seq)| Adapter {
name: format!("primer_{i}"),
seq,
role: Role::Primer,
})
.collect();
let found = infer_with_known(&reads, known);
assert!(found.is_empty(), "{found:?}");
}
#[test]
fn template_begins_behind_the_primer_not_at_its_degenerate_base() {
let (reads, forward, _) = community_amplicon_reads();
let windows: Vec<&[u8]> = reads.iter().map(|r| &r[..200.min(r.len())]).collect();
let mut primer = forward.clone();
primer[8] = b'C';
assert_eq!(
template_start(&primer, &windows, End::Five, 0.2).0,
Some(TemplateStart::Behind)
);
assert_eq!(
template_start(&primer[..14], &windows, End::Five, 0.2).0,
None
);
let mut into_template = primer.clone();
into_template.extend_from_slice(&community_templates()[0][..12]);
assert_eq!(
template_start(&into_template, &windows, End::Five, 0.2).0,
Some(TemplateStart::Inside(primer.len()))
);
}
#[test]
fn candidates_end_at_a_known_insert_boundary() {
let primer = b"AGAGTTTGATYMTGGCTCAG";
let mut through = b"TTTGATCATGGCTCAG".to_vec();
through.extend_from_slice(b"GACGAACG");
assert_eq!(past_boundary(&through, primer, End::Five), Some(16));
let eroded = b"TGGCTCAGGACGAACGCTGG";
assert_eq!(past_boundary(eroded, primer, End::Five), Some(8));
let rear = rc(primer);
let mut three = b"CGTTCGTC".to_vec();
three.extend_from_slice(&rear[..9]);
assert_eq!(past_boundary(&three, &rear, End::Three), Some(9));
assert_eq!(past_boundary(b"TTTGATCATGGCTCAG", primer, End::Five), None);
}
fn boundary_windows(primed: bool) -> Vec<Vec<u8>> {
let templates = community_templates();
let (forward, reverse) = (random_bases(61_011, 20), random_bases(61_012, 22));
(0..1600u64)
.map(|i| {
let template = &templates[(i % 16) as usize];
let (primer, insert) = if (i / 16) % 2 == 0 {
(&forward, template[..180].to_vec())
} else {
(&reverse, rc(template)[..180].to_vec())
};
let mut window = if primed { primer.clone() } else { Vec::new() };
window.extend_from_slice(&insert);
with_errors(&window, 63_000 + i, 20)
})
.collect()
}
#[test]
fn template_begins_at_a_boundary_only_behind_the_primers() {
let primed = boundary_windows(true);
let primed: Vec<&[u8]> = primed.iter().map(Vec::as_slice).collect();
assert!(!template_at_boundary(&primed, End::Five));
let inserts = boundary_windows(false);
let inserts: Vec<&[u8]> = inserts.iter().map(Vec::as_slice).collect();
assert!(template_at_boundary(&inserts, End::Five));
}