pub mod adapter;
pub(crate) mod banner;
pub mod cli;
pub mod config;
pub mod filter;
pub(crate) mod guards;
pub mod io;
pub mod mods;
pub mod obs;
pub mod qual;
pub mod record;
pub mod summary;
pub mod tagfilter;
pub mod trim;
pub mod workflow;
pub use banner::command_line;
use std::borrow::Cow;
use std::io::{BufReader, Read};
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::Instant;
use anyhow::Context as _;
pub use config::Config;
use io::Format;
pub fn run(cfg: Config, obs: &mut obs::ProgressHandle) -> anyhow::Result<()> {
let mut cfg = cfg;
let dir = cfg
.io
.input
.as_deref()
.filter(|p| p.is_dir())
.map(Path::to_path_buf);
let result = match dir {
Some(dir) => run_folder(&dir, &mut cfg, obs),
None => run_single(&mut cfg, obs),
};
emit_advisories(&mut cfg.advisories);
result
}
fn run_single(cfg: &mut Config, obs: &mut obs::ProgressHandle) -> anyhow::Result<()> {
let setup_start = Instant::now();
guards::guard_output_collisions(cfg, &[])?;
let in_path = cfg.io.input.clone();
let in_path = in_path.as_deref();
let total: Option<u64> = in_path
.and_then(|p| std::fs::metadata(p).ok())
.map(|m| m.len());
let counters = Arc::new(workflow::Counters::default());
let raw: Box<dyn Read + Send> = match in_path {
Some(p) => Box::new(
std::fs::File::open(p).with_context(|| format!("opening input {}", p.display()))?,
),
None => Box::new(std::io::stdin()),
};
let raw: Box<dyn Read + Send> =
Box::new(io::counting::CountingReader::new(raw, counters.clone()));
let mut source: Box<dyn Read + Send> = Box::new(BufReader::new(raw));
let in_fmt = match cfg.io.in_format {
Some(forced) => {
let (detected, replayed) = detect_format(in_path, source).with_context(|| {
format!(
"--input-format {} but the input does not look like {}",
forced.label(),
forced.label()
)
})?;
source = replayed;
match detected {
None => forced,
Some(d) if io::forced_format_accepts(forced, d) => d,
Some(d) => anyhow::bail!(
"--input-format {} but the input is {}; drop the flag or pass --input-format {}",
forced.label(),
d.label(),
d.flag_value()
),
}
},
None => match in_path.and_then(io::from_extension) {
Some(Format::FastqGz) => io::probe_gz(&mut source)?,
Some(f) => f,
None => {
let (fmt, replayed) = detect_format(in_path, source)?;
source = replayed;
fmt.ok_or_else(|| {
anyhow::anyhow!("cannot determine input format; pass --input-format")
})?
},
},
};
let mismatch_warn = io::format_mismatch_warning("--input-format", cfg.io.in_format, in_path);
let out_mismatch_warn = io::format_mismatch_warning(
"--output-format",
cfg.io.out_format,
cfg.io.output.as_deref(),
);
let out_fmt = cfg
.io
.out_format
.unwrap_or_else(|| io::resolve_output(cfg.io.output.as_deref(), in_fmt));
guards::guard_stdout_binary(cfg, out_fmt)?;
guards::guard_bam_only_flags(cfg, in_fmt)?;
guards::guard_fastq_to_bam(in_fmt, out_fmt)?;
tracing::debug!(
stage = "setup",
format = in_fmt.label(),
elapsed_ms = setup_start.elapsed().as_millis() as u64,
"Input format detected"
);
let budget = plan_budget(
cfg,
match in_fmt {
Format::FastqBgzf | Format::Bam => config::Decode::Blocks,
Format::FastqGz => config::Decode::Stream,
Format::Fastq => config::Decode::Inline,
},
);
let mut warnings: Vec<String> = Vec::new();
warnings.extend(mismatch_warn);
warnings.extend(out_mismatch_warn);
if cfg.io.out_format.is_none() {
warnings.extend(io::unknown_extension_warning(
cfg.io.output.as_deref(),
out_fmt,
));
}
if is_no_op(cfg, in_fmt == out_fmt) {
warnings.push(NO_OP_WARNING.to_string());
}
announce(
cfg,
obs,
counters.clone(),
&Startup {
input_line: match (in_path, total) {
(Some(p), Some(size)) => {
format!("Input: {} ({})", p.display(), obs::human_bytes(size))
},
(Some(p), None) => format!("Input: {}", p.display()),
(None, _) => "Input: <stdin>".to_string(),
},
total,
in_fmt,
out_fmt,
budget,
warnings,
},
);
let session = Session::begin(cfg, budget, counters, in_fmt, out_fmt);
session.dispatch(cfg, obs, in_fmt, out_fmt, Source::Stream(source))
}
fn run_folder(dir: &Path, cfg: &mut Config, obs: &mut obs::ProgressHandle) -> anyhow::Result<()> {
let folder_in_format_ignored = cfg.io.in_format.is_some();
let (family, paths) = io::dir::classify(dir, cfg.io.output.as_deref())?;
guards::guard_output_collisions(cfg, &paths)?;
let family_fmt = match family {
io::dir::Family::Fastq => Format::Fastq,
io::dir::Family::Bam => Format::Bam,
};
let out_fmt = cfg
.io
.out_format
.unwrap_or_else(|| io::resolve_output(cfg.io.output.as_deref(), family_fmt));
guards::guard_stdout_binary(cfg, out_fmt)?;
guards::guard_bam_only_flags(cfg, family_fmt)?;
guards::guard_fastq_to_bam(family_fmt, out_fmt)?;
let decode = if family_fmt == Format::Bam {
config::Decode::Blocks
} else {
paths
.iter()
.map(|p| match io::from_extension(p) {
Some(Format::FastqBgzf) => config::Decode::Blocks,
Some(Format::FastqGz) if io::is_bgzf_file(p) => config::Decode::Blocks,
Some(Format::FastqGz) => config::Decode::Stream,
_ => config::Decode::Inline,
})
.max()
.unwrap_or(config::Decode::Inline)
};
let budget = plan_budget(cfg, decode);
let counters = Arc::new(workflow::Counters::default());
let total_bytes: u64 = paths
.iter()
.filter_map(|p| std::fs::metadata(p).ok())
.map(|m| m.len())
.sum();
tracing::debug!(
stage = "setup",
format = family_fmt.label(),
files = paths.len(),
"Folder classified"
);
let mut warnings: Vec<String> = Vec::new();
if folder_in_format_ignored {
warnings.push(
"--input-format is ignored for a directory input; folder files are classified by \
extension per file"
.to_string(),
);
}
warnings.extend(io::format_mismatch_warning(
"--output-format",
cfg.io.out_format,
cfg.io.output.as_deref(),
));
let same_format = paths.iter().all(|p| io::from_extension(p) == Some(out_fmt));
if is_no_op(cfg, same_format) {
warnings.push(NO_OP_WARNING.to_string());
}
announce(
cfg,
obs,
counters.clone(),
&Startup {
input_line: format!(
"Input: {} {} files, {}",
paths.len(),
family_fmt.label(),
obs::human_bytes(total_bytes)
),
total: Some(total_bytes),
in_fmt: family_fmt,
out_fmt,
budget,
warnings,
},
);
let session = Session::begin(cfg, budget, counters, family_fmt, out_fmt);
session.dispatch(cfg, obs, family_fmt, out_fmt, Source::Folder(paths))
}
fn detect_format(
in_path: Option<&Path>,
mut source: Box<dyn Read + Send>,
) -> anyhow::Result<(Option<Format>, Box<dyn Read + Send>)> {
let mut probe = [0u8; 18];
let n = io::fill(&mut source, &mut probe)?;
let mut replay = probe[..n].to_vec();
if n == 0 {
return Ok((None, source));
}
let fmt = if io::is_bgzf(&replay) {
let block_size = usize::from(u16::from_le_bytes([replay[16], replay[17]])) + 1;
if block_size < replay.len() {
anyhow::bail!("invalid BGZF block size {block_size}");
}
replay.resize(block_size, 0);
source.read_exact(&mut replay[n..]).with_context(|| {
format!(
"truncated BGZF block in {}",
in_path.map_or_else(|| "<stdin>".to_string(), |p| p.display().to_string())
)
})?;
io::detect_bgzf_block(&replay)?
} else {
io::detect_input(&replay)?
};
Ok((
Some(fmt),
Box::new(std::io::Cursor::new(replay).chain(source)),
))
}
fn plan_budget(cfg: &Config, decode: config::Decode) -> config::ThreadBudget {
config::thread_budget(cfg.threads, decode)
}
enum Source {
Stream(Box<dyn Read + Send>),
Folder(Vec<PathBuf>),
}
struct Session {
budget: config::ThreadBudget,
counters: Arc<workflow::Counters>,
out_desc: String,
t0: Instant,
}
impl Session {
fn begin(
cfg: &Config,
budget: config::ThreadBudget,
counters: Arc<workflow::Counters>,
in_fmt: Format,
out_fmt: Format,
) -> Self {
tracing::debug!(
stage = "dispatch",
input = in_fmt.label(),
output = out_fmt.label(),
threads = cfg.threads,
decode = budget.decode,
render = budget.render,
"Processing started"
);
Session {
budget,
counters,
out_desc: banner::output_desc(cfg.io.output.as_deref()),
t0: Instant::now(),
}
}
fn dispatch(
self,
cfg: &mut Config,
obs: &mut obs::ProgressHandle,
in_fmt: Format,
out_fmt: Format,
source: Source,
) -> anyhow::Result<()> {
match (in_fmt, out_fmt) {
(Format::Bam, Format::Bam) => {
note_tags_ignored(cfg, in_fmt, out_fmt);
let (header, records) = self.bam_reader(source, true)?;
let mut out_header = io::bam::provenance_header(
header,
cfg.threads <= 1 || cfg.ordered,
&command_line(std::env::args_os()),
);
let rejects = self.start_rejects(cfg, out_fmt, Some(&out_header))?;
let records = self.tag_filtered_bam(cfg, records, out_fmt);
let Some(records) = settle(
records,
cfg,
self.budget,
adapter::resolve::bam_seq,
adapter::resolve::bam_sample_weight,
)?
else {
return Ok(());
};
io::bam::merge_trim_mode(&mut out_header, cfg.trim_classes);
let mut sink = io::bam::writer(
cfg.io.output.as_deref(),
&out_header,
cfg.threads > 1,
cfg.compression_level,
)?;
let stats =
workflow::run_raw_bam(&out_header, records, &mut sink, cfg, &self.counters)?;
sink.finish()?;
finish_rejects(rejects)?;
self.finish(obs, &stats, cfg)
},
(Format::Bam, Format::Fastq | Format::FastqGz | Format::FastqBgzf) => {
note_update_moves_ignored(cfg, out_fmt);
let (_header, records) = self.bam_reader(source, false)?;
let rejects = self.start_rejects(cfg, out_fmt, None)?;
let records = self.tag_filtered_bam(cfg, records, out_fmt);
let Some(records) = settle(
records,
cfg,
self.budget,
adapter::resolve::bam_seq,
adapter::resolve::bam_sample_weight,
)?
else {
return Ok(());
};
let mut writer = io::fastq::writer(cfg, out_fmt, cfg.threads > 1)?;
let stats = workflow::run_bam_to_fastq(records, &mut writer, cfg, &self.counters)?;
writer.finish()?;
finish_rejects(rejects)?;
self.finish(obs, &stats, cfg)
},
(Format::Fastq | Format::FastqGz | Format::FastqBgzf, Format::Bam) => {
anyhow::bail!("FASTQ-to-BAM conversion is not supported")
},
(Format::Fastq | Format::FastqGz | Format::FastqBgzf, _) => {
let rejects = self.start_rejects(cfg, out_fmt, None)?;
#[cfg(feature = "paraseq")]
let mut source = source;
#[cfg(feature = "paraseq")]
let sampling = cfg.adapter_infer != config::AdapterInfer::Off
|| cfg
.adapters
.as_ref()
.is_some_and(|a| !a.adapters.is_empty());
#[cfg(feature = "paraseq")]
let paraseq = workflow::paraseq_selected()
&& !sampling
&& cfg.tag_filters.is_empty()
&& in_fmt != Format::FastqBgzf
&& cfg.threads > 1;
#[cfg(feature = "paraseq")]
if let (true, Source::Stream(src)) = (paraseq, &mut source) {
let src = std::mem::replace(src, Box::new(std::io::empty()));
cfg.render_workers = self.budget.render;
let stream = io::fastq::byte_stream(src, in_fmt == Format::FastqGz, true);
let mut writer = io::fastq::writer(cfg, out_fmt, true)?;
let stats =
workflow::run_fastq_paraseq(stream, &mut writer, cfg, &self.counters)?;
let tagged = self
.counters
.tagged_fastq
.load(std::sync::atomic::Ordering::Relaxed);
writer.finish()?;
finish_rejects(rejects)?;
guards::guard_tag_flags(cfg, in_fmt, tagged)?;
if !tagged {
note_tags_ignored(cfg, in_fmt, out_fmt);
}
return self.finish(obs, &stats, cfg);
}
let records = self.fastq_reader(source, in_fmt, cfg.threads > 1)?;
let records = self.tag_filtered_fastq(cfg, records);
let Some(records) = settle(
records,
cfg,
self.budget,
|r| Cow::Borrowed(r.seq.as_slice()),
|r| {
(
std::mem::size_of::<record::ReadRecord>()
+ r.name.capacity()
+ r.seq.capacity()
+ r.qual.capacity(),
r.seq.len(),
)
},
)?
else {
return Ok(());
};
let mut writer = io::fastq::writer(cfg, out_fmt, cfg.threads > 1)?;
let stats = workflow::run_fastq(records, &mut writer, cfg, &self.counters)?;
let tagged = self
.counters
.tagged_fastq
.load(std::sync::atomic::Ordering::Relaxed);
writer.finish()?;
finish_rejects(rejects)?;
guards::guard_tag_flags(cfg, in_fmt, tagged)?;
if !tagged {
note_tags_ignored(cfg, in_fmt, out_fmt);
}
self.finish(obs, &stats, cfg)
},
}
}
fn bam_reader(
&self,
source: Source,
check_read_groups: bool,
) -> anyhow::Result<(noodles_sam::Header, io::bam::RawRecordIter)> {
match source {
Source::Stream(src) => io::bam::reader_from(src, self.budget.decode),
Source::Folder(paths) => io::dir::bam_reader(
&paths,
self.budget.decode,
self.counters.clone(),
check_read_groups,
),
}
}
fn tag_filtered_bam(
&self,
cfg: &Config,
records: io::bam::RawRecordIter,
out_fmt: Format,
) -> io::bam::RawRecordIter {
if cfg.tag_filters.is_empty() {
return records;
}
let filters = cfg.tag_filters.clone();
let counters = Arc::clone(&self.counters);
let cfg = cfg.clone();
workflow::filter_by_tags(
records,
Arc::clone(&self.counters),
move |rec| filters.keeps(rec),
|rec| rec.sequence().len(),
|rec| io::bam::display_name(rec.name().map(AsRef::as_ref)),
move |rec| {
if !counters.wants_rejects() {
return Ok(());
}
let item = if out_fmt == Format::Bam {
workflow::bam::tag_filtered_bam(rec)?
} else {
workflow::bam::tag_filtered_bam_fastq(rec, &cfg)?
};
counters.reject(item)
},
)
}
fn start_rejects(
&self,
cfg: &Config,
out_fmt: Format,
header: Option<&noodles_sam::Header>,
) -> anyhow::Result<Option<workflow::reject::RejectWriter>> {
let Some(path) = cfg.rejected_output.as_deref() else {
return Ok(None);
};
let format = workflow::reject::resolve_format(path, out_fmt)?;
let (rejects, writer) = workflow::reject::RejectWriter::start(
path,
format,
cfg.compression_level,
header.cloned(),
cfg.threads.max(1),
)?;
self.counters
.rejects
.set(rejects)
.map_err(|_| anyhow::anyhow!("the rejected output was opened twice"))?;
Ok(Some(writer))
}
fn tag_filtered_fastq(
&self,
cfg: &Config,
records: Box<dyn Iterator<Item = anyhow::Result<record::ReadRecord>> + Send>,
) -> Box<dyn Iterator<Item = anyhow::Result<record::ReadRecord>> + Send> {
if cfg.tag_filters.is_empty() {
return records;
}
let filters = cfg.tag_filters.clone();
let counters = Arc::clone(&self.counters);
workflow::filter_by_tags(
records,
Arc::clone(&self.counters),
move |rec| {
if !io::tagged::has_aux_tags(&rec.name) {
return filters.keeps(&tagfilter::NoTags);
}
counters
.tagged_fastq
.store(true, std::sync::atomic::Ordering::Relaxed);
let fields = rec
.name
.iter()
.position(|&b| b == b'\t')
.map_or(&[][..], |t| &rec.name[t + 1..]);
let data = io::tagged::parse_aux_fields(fields)?;
filters.keeps(&data)
},
|rec| rec.seq.len(),
|rec| {
String::from_utf8_lossy(
rec.name
.split(|&b| b == b'\t' || b == b' ')
.next()
.unwrap_or(&[]),
)
.into_owned()
},
{
let counters = Arc::clone(&self.counters);
move |rec| {
if !counters.wants_rejects() {
return Ok(());
}
counters.reject(workflow::reject::RejectItem::Fastq(
workflow::tag_filtered_fastq(rec),
))
}
},
)
}
fn fastq_reader(
&self,
source: Source,
in_fmt: Format,
threaded: bool,
) -> anyhow::Result<Box<dyn Iterator<Item = anyhow::Result<record::ReadRecord>> + Send>> {
match source {
Source::Stream(src) => match in_fmt {
Format::Fastq => Ok(io::fastq::reader_from(src, false, false)),
Format::FastqGz => Ok(io::fastq::reader_from(src, true, threaded)),
Format::FastqBgzf => io::fastq::reader_from_bgzf(src, self.budget.decode),
Format::Bam => unreachable!("BAM input is dispatched to bam_reader"),
},
Source::Folder(paths) => Ok(io::dir::fastq_records(
&paths,
self.budget.decode,
threaded,
self.counters.clone(),
)),
}
}
fn finish(
&self,
obs: &mut obs::ProgressHandle,
stats: &workflow::Stats,
cfg: &Config,
) -> anyhow::Result<()> {
tracing::debug!(
stage = "dispatch",
elapsed_ms = self.t0.elapsed().as_millis() as u64,
reads_in = stats.input_reads,
reads_out = stats.output_reads,
bases_in = stats.input_bases,
bases_out = stats.output_bases,
"Processing finished"
);
let elapsed = obs.finish(stats);
if let Some(path) = cfg.summary_json.as_deref() {
summary::Summary::new(
cfg,
stats,
command_line(std::env::args_os()),
self.out_desc.clone(),
elapsed,
)
.write(path)?;
}
obs.complete(elapsed, &self.out_desc);
Ok(())
}
}
fn settle<R, I, F>(
records: I,
cfg: &mut Config,
budget: config::ThreadBudget,
seq_of: F,
weight: impl Fn(&R) -> (usize, usize),
) -> anyhow::Result<Option<Box<dyn Iterator<Item = anyhow::Result<R>> + Send>>>
where
I: Iterator<Item = anyhow::Result<R>> + Send + 'static,
R: Send + 'static,
F: for<'a> Fn(&'a R) -> std::borrow::Cow<'a, [u8]>,
{
let Some(resolved) = adapter::resolve::resolve(records, cfg, seq_of, weight)? else {
note_report_only_ignores(cfg);
return Ok(None);
};
cfg.adapters_configured = cfg.adapters.as_ref().map(|a| a.adapters.len());
cfg.adapters = resolved.adapters;
cfg.trim_classes = trim_classes(cfg);
cfg.render_workers = budget.render;
Ok(Some(resolved.records))
}
fn trim_classes(cfg: &Config) -> [bool; 3] {
let mut classes = [false; 3];
for adapter in cfg.adapters.iter().flat_map(|a| &a.adapters) {
let class = match adapter.role {
adapter::Role::Adapter => 0,
adapter::Role::Primer => 1,
adapter::Role::Barcode => 2,
};
classes[class] = true;
}
classes
}
fn note_report_only_ignores(cfg: &Config) {
for (flag, _) in cfg.write_targets() {
tracing::warn!("{flag} is ignored under --adapter-report, which writes no records");
}
}
struct Startup {
input_line: String,
total: Option<u64>,
in_fmt: Format,
out_fmt: Format,
budget: config::ThreadBudget,
warnings: Vec<String>,
}
fn announce(
cfg: &mut Config,
obs: &mut obs::ProgressHandle,
counters: Arc<workflow::Counters>,
s: &Startup,
) {
if obs.shows_lines() {
tracing::info!("{}", banner::operation_line(s.in_fmt, s.out_fmt));
tracing::info!("{}", s.input_line);
tracing::info!(
"{}",
banner::output_banner_line(cfg.io.output.as_deref(), s.out_fmt, cfg.compression_level)
);
tracing::info!("{}", banner::threads_banner_line(cfg.threads, s.budget));
if let Some(p) = cfg.rejected_output.as_deref() {
tracing::info!("Rejected: {}", p.display());
}
tracing::info!("{}", banner::filters_and_trim_line(&cfg.filter, &cfg.trim));
for text in cfg.tag_filters.texts() {
tracing::info!("Tag filter: {text}");
}
if let Some(line) = banner::adapter_banner_line(
cfg.adapters.as_ref(),
cfg.adapter_sample,
cfg.adapter_infer,
) {
tracing::info!("{line}");
}
} else if obs.is_bar() {
tracing::info!(
"{} ({} threads)",
banner::operation_line(s.in_fmt, s.out_fmt),
cfg.threads
);
}
emit_advisories(&mut cfg.advisories);
if let Some((requested, ncpu)) = cfg.threads_clamped {
tracing::warn!(
requested,
ncpu,
"Requested -t exceeds the CPU count; using the CPU count"
);
}
for w in &s.warnings {
tracing::warn!("{w}");
}
obs.start(s.total, counters);
}
fn emit_advisories(advisories: &mut Vec<config::Advisory>) {
for a in advisories.drain(..) {
if a.warn {
tracing::warn!("{}", a.message);
} else {
tracing::info!("{}", a.message);
}
}
}
fn is_no_op(cfg: &Config, same_format: bool) -> bool {
let no_trim = cfg.trim.head == 0 && cfg.trim.tail == 0 && cfg.trim.quality.is_none();
let pass_through_filter = cfg.filter.min_length <= 1
&& cfg.filter.max_length == usize::MAX
&& cfg.filter.min_qual <= 0.0
&& cfg.filter.max_qual >= 1000.0
&& cfg.filter.max_expected_errors.is_none()
&& cfg.filter.min_gc.is_none()
&& cfg.filter.max_gc.is_none();
no_trim
&& pass_through_filter
&& cfg.adapters.is_none()
&& cfg.remove_tags.is_empty()
&& cfg.tag_filters.is_empty()
&& same_format
}
fn finish_rejects(writer: Option<workflow::reject::RejectWriter>) -> anyhow::Result<()> {
match writer {
Some(writer) => writer.finish(),
None => Ok(()),
}
}
const NO_OP_WARNING: &str =
"No trimming or filtering options set; output will mostly mirror the input";
fn note_tags_ignored(cfg: &Config, in_fmt: Format, out_fmt: Format) {
if !matches!(cfg.fastq_tags, config::FastqTags::All) {
tracing::warn!(
input = in_fmt.label(),
output = out_fmt.label(),
"--fastq-tags applies only to BAM-to-FASTQ output and is ignored"
);
}
}
fn note_update_moves_ignored(cfg: &Config, out_fmt: Format) {
if cfg.update_moves {
tracing::warn!(
output = out_fmt.label(),
"--update-moves applies only to BAM-to-BAM output and is ignored"
);
}
}
#[cfg(test)]
mod tests {
use super::*;
fn a_read() -> crate::record::ReadRecord {
crate::record::ReadRecord {
name: b"r1".to_vec(),
seq: b"ACGTACGTACGT".to_vec(),
qual: vec![40; 12],
}
}
#[test]
fn settle_sets_both_dispatch_fields() {
let mut cfg = base_config();
cfg.render_workers = 0;
cfg.adapters = None;
let budget = config::ThreadBudget {
decode: 1,
render: 5,
};
let records = vec![Ok(a_read())].into_iter();
let got = settle(
records,
&mut cfg,
budget,
|r| Cow::Borrowed(r.seq.as_slice()),
|r| (r.name.len() + r.seq.len() + r.qual.len(), r.seq.len()),
)
.expect("Settle succeeds")
.expect("Records are returned when not in report mode");
assert_eq!(
cfg.render_workers, 5,
"Render pool size comes from the budget"
);
assert!(cfg.adapters.is_none(), "No adapters configured stays none");
assert_eq!(got.count(), 1, "The record stream is handed back intact");
}
#[test]
fn settle_passes_records_through_when_adapters_are_off() {
let mut cfg = base_config();
let budget = config::ThreadBudget {
decode: 1,
render: 1,
};
let records = (0..7).map(|_| Ok(a_read()));
let got = settle(
records,
&mut cfg,
budget,
|r| Cow::Borrowed(r.seq.as_slice()),
|r| (r.name.len() + r.seq.len() + r.qual.len(), r.seq.len()),
)
.unwrap()
.unwrap();
assert_eq!(got.count(), 7);
}
fn base_config() -> Config {
Config {
threads: 8,
quiet: true,
..Config::default()
}
}
}