use std::io::Read as _;
use std::path::Path;
use std::process::Stdio;
use assert_cmd::Command;
use predicates::prelude::*;
fn whittle() -> Command {
let mut cmd = Command::cargo_bin("whittle").unwrap();
cmd.env_remove("WHITTLE_LOG");
cmd
}
const READS: &str = "@r1\nACGTACGTACGTACGTACGT\n+\nIIIIIIIIIIIIIIIIIIII\n";
#[test]
fn version_is_long_only() {
whittle()
.arg("--version")
.assert()
.success()
.stdout(predicate::str::contains(env!("CARGO_PKG_VERSION")));
whittle()
.arg("-V")
.assert()
.failure()
.stderr(predicate::str::contains("unexpected argument '-V'"));
}
#[test]
fn verbosity_above_trace_is_rejected() {
whittle()
.args(["-vvv", "--input-format", "fastq"])
.write_stdin("")
.assert()
.failure()
.stderr(predicate::str::contains("accepts at most -vv"));
}
#[test]
fn head_tail_crop_over_stdin() {
for (front, tail) in [
("--trim-front", "--trim-tail"),
("--head-crop", "--tail-crop"),
("--trim-front", "--tail-crop"),
("--head-crop", "--trim-tail"),
("-H", "-T"),
] {
whittle()
.args([front, "1", tail, "1", "--input-format", "fastq"])
.write_stdin("@r1\nACGT\n+\nIIII\n")
.assert()
.success()
.stdout("@r1\nCG\n+\nII\n");
}
}
#[test]
fn quality_mode_filters_segments_without_changing_split_locations() {
let input = "@r1\nACGTACGTACG\n+\nII#II##IIII\n";
let split = "@r1_segment_1\nACGTA\n+\nII#II\n@r1_segment_2\nTACG\n+\nIIII\n";
for mode in ["mean", "arithmetic", "median"] {
whittle()
.args([
"--quality-trim",
"runs",
"--quality-cutoff",
"9",
"--min-low-quality-run",
"2",
"--quality-mode",
mode,
"--threads",
"1",
"--quiet",
])
.write_stdin(input)
.assert()
.success()
.stdout(split);
let expected = if mode == "mean" {
"@r1_segment_2\nTACG\n+\nIIII\n"
} else {
split
};
whittle()
.args([
"--quality-trim",
"runs",
"--quality-cutoff",
"9",
"--min-low-quality-run",
"2",
"--quality-mode",
mode,
"--min-quality",
"12",
"--threads",
"1",
"--quiet",
])
.write_stdin(input)
.assert()
.success()
.stdout(expected);
}
}
#[test]
fn quality_trim_flag_combinations_are_validated() {
for (args, message) in [
(
&["--quality-trim", "ends"][..],
"--quality-trim requires --quality-cutoff",
),
(
&["--quality-cutoff", "10"],
"--quality-cutoff requires --quality-trim",
),
(
&[
"--quality-trim",
"best",
"--quality-cutoff",
"10",
"--min-low-quality-run",
"5",
],
"--min-low-quality-run requires --quality-trim runs",
),
(
&[
"--quality-trim",
"runs",
"--quality-cutoff",
"10",
"--min-low-quality-run",
"0",
],
"--min-low-quality-run must be at least 1",
),
(
&["--quality-trim", "middle", "--quality-cutoff", "10"],
"invalid value",
),
(
&[
"--quality-trim",
"ends",
"--quality-cutoff",
"10",
"--quality-end-cutoff",
"20",
],
"--quality-end-cutoff requires --quality-trim segments or runs",
),
(
&[
"--quality-trim",
"best",
"--quality-cutoff",
"10",
"--quality-end-cutoff",
"20",
],
"--quality-end-cutoff requires --quality-trim segments or runs",
),
(
&["--quality-end-cutoff", "20"],
"--quality-end-cutoff requires --quality-trim segments or runs",
),
] {
whittle()
.args(args)
.args(["--input-format", "fastq"])
.write_stdin("@r1\nACGT\n+\nIIII\n")
.assert()
.failure()
.stderr(predicate::str::contains(message));
}
}
#[test]
fn min_length_filters() {
whittle()
.args(["--min-length", "10", "--input-format", "fastq"])
.write_stdin("@short\nACGT\n+\nIIII\n")
.assert()
.success()
.stdout(""); }
#[test]
fn same_input_output_file_is_rejected_and_preserves_input() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("reads.fastq");
std::fs::write(&path, "@r1\nACGT\n+\nIIII\n@r2\nTTTT\n+\nIIII\n").unwrap();
let before = std::fs::read(&path).unwrap();
let assert = whittle()
.arg("-i")
.arg(&path)
.arg("-o")
.arg(&path)
.assert()
.failure()
.stderr(predicate::str::contains("same file"));
let stderr = String::from_utf8_lossy(&assert.get_output().stderr);
assert_eq!(
stderr.matches("Failed after").count(),
1,
"Exactly one failure line is printed: {stderr}"
);
assert_eq!(
std::fs::read(&path).unwrap(),
before,
"Input must not be modified"
);
}
#[test]
fn contradictory_length_bounds_error() {
whittle()
.args(["-l", "10", "-L", "5", "--input-format", "fastq"])
.write_stdin("@r1\nACGTACGTAC\n+\nIIIIIIIIII\n")
.assert()
.failure()
.stderr(predicate::str::contains("min-length"));
}
#[test]
fn contradictory_qual_bounds_error() {
whittle()
.args(["-q", "30", "-Q", "20", "--input-format", "fastq"])
.write_stdin("@r1\nACGT\n+\nIIII\n")
.assert()
.failure()
.stderr(predicate::str::contains("min-qual"));
}
#[test]
fn out_of_range_gc_bound_errors() {
whittle()
.args(["--min-gc", "2", "--input-format", "fastq"])
.write_stdin("@r1\nACGT\n+\nIIII\n")
.assert()
.failure()
.stderr(predicate::str::contains("min-gc"));
}
#[test]
fn nan_quality_bound_errors() {
whittle()
.args(["--min-quality", "nan", "--input-format", "fastq"])
.write_stdin("@r1\nACGT\n+\nIIII\n")
.assert()
.failure()
.stderr(predicate::str::contains("NaN"));
}
enum Expect {
Fails,
Warns,
}
#[test]
fn every_validation_names_its_flag() {
use std::io::Write as _;
let dir = tempfile::tempdir().unwrap();
let fastq = dir.path().join("reads.fastq");
std::fs::write(&fastq, READS).unwrap();
let misnamed_gz = dir.path().join("misnamed.fastq");
let mut enc = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::default());
enc.write_all(READS.as_bytes()).unwrap();
std::fs::write(&misnamed_gz, enc.finish().unwrap()).unwrap();
let folder = dir.path().join("folder");
std::fs::create_dir(&folder).unwrap();
std::fs::write(folder.join("a.fastq"), READS).unwrap();
let missing = dir.path().join("no-such-adapters.fasta");
let p = |path: &Path| path.to_str().unwrap().to_string();
let cases: Vec<(Vec<String>, Expect, &str)> = vec![
(
vec!["--compression-level".into(), "10".into()],
Expect::Fails,
"--compression-level",
),
(
vec!["--max-gc".into(), "1.5".into()],
Expect::Fails,
"--max-gc (1.5) must be a fraction",
),
(
vec![
"--min-gc".into(),
"0.8".into(),
"--max-gc".into(),
"0.2".into(),
],
Expect::Fails,
"--min-gc (0.8) must not exceed --max-gc",
),
(
vec!["--max-quality".into(), "nan".into()],
Expect::Fails,
"NaN",
),
(
vec!["--min-quality=-5".into()],
Expect::Fails,
"--min-quality (-5) must be a finite quality",
),
(
vec!["--max-expected-errors=-0.5".into()],
Expect::Fails,
"--max-expected-errors (-0.5) must be a finite number of at least 0",
),
(
vec!["--max-expected-errors".into(), "nan".into()],
Expect::Fails,
"--max-expected-errors (NaN) must be a finite number",
),
(
vec!["--max-quality".into(), "inf".into()],
Expect::Fails,
"--max-quality (inf) must be a finite quality",
),
(vec!["-t".into(), "0".into()], Expect::Fails, "--threads"),
(
vec!["--fastq-tags".into(), "MM,ABC".into()],
Expect::Fails,
"--fastq-tags: invalid tag",
),
(
vec!["--min-low-quality-run".into(), "5".into()],
Expect::Fails,
"--min-low-quality-run requires --quality-trim runs",
),
(
vec!["--progress".into(), "bar".into(), "--quiet".into()],
Expect::Fails,
"cannot be used with",
),
(
vec!["--adapter-fasta".into(), p(&missing)],
Expect::Fails,
"--adapter-fasta",
),
(
vec![
"--adapter-preset".into(),
"ont".into(),
"--adapter-end-search".into(),
"0".into(),
],
Expect::Fails,
"--adapter-end-search must be >= 1",
),
(
vec![
"--adapter-discover".into(),
"--adapter-sample-reads".into(),
"0".into(),
],
Expect::Fails,
"--adapter-sample-reads 0 disables sampling",
),
(
vec!["--adapter-error-rate".into(), "0.5".into()],
Expect::Fails,
"--adapter-error-rate requires an adapter source",
),
(
vec!["--adapter-end-search".into(), "50".into()],
Expect::Fails,
"--adapter-end-search requires an adapter source",
),
(
vec!["--adapter-sample-reads".into(), "50".into()],
Expect::Fails,
"--adapter-sample-reads requires an adapter source",
),
(
vec![
"-i".into(),
p(&misnamed_gz),
"--input-format".into(),
"fastq-gz".into(),
"-o".into(),
p(&dir.path().join("out_in_mismatch.fastq")),
],
Expect::Warns,
"--input-format",
),
(
vec![
"-i".into(),
p(&fastq),
"-o".into(),
p(&dir.path().join("out_out_mismatch.fastq.gz")),
"--output-format".into(),
"fastq".into(),
],
Expect::Warns,
"--output-format",
),
(
vec![
"-i".into(),
p(&folder),
"--input-format".into(),
"fastq".into(),
"-o".into(),
p(&dir.path().join("out_folder.fastq")),
],
Expect::Warns,
"--input-format is ignored for a directory input",
),
(
vec![
"-i".into(),
p(&fastq),
"-o".into(),
p(&dir.path().join("out_noop.fastq")),
],
Expect::Warns,
"No trimming or filtering options set",
),
(
vec![
"-i".into(),
p(&fastq),
"-o".into(),
p(&dir.path().join("out.bam")),
],
Expect::Fails,
"FASTQ-to-BAM conversion is not supported",
),
(
vec![
"-i".into(),
p(&fastq),
"-o".into(),
p(&dir.path().join("out_sum.fastq")),
"--summary-json".into(),
p(dir.path()),
],
Expect::Fails,
"--summary-json",
),
];
for (args, expect, needle) in cases {
let mut cmd = whittle();
cmd.args(&args);
if !args.iter().any(|a| a == "-i") {
cmd.args(["--input-format", "fastq"]).write_stdin(READS);
}
let output = cmd.output().unwrap();
let stderr = String::from_utf8_lossy(&output.stderr);
match expect {
Expect::Fails => assert!(
!output.status.success(),
"Case {args:?} must fail: {stderr}"
),
Expect::Warns => assert!(
output.status.success(),
"Case {args:?} must succeed: {stderr}"
),
}
assert!(
stderr.contains(needle),
"Case {args:?}: stderr lacks {needle:?}: {stderr}"
);
}
}
#[test]
fn missing_input_error_names_the_path() {
let dir = tempfile::tempdir().unwrap();
let missing = dir.path().join("nonexistent.fastq");
whittle()
.arg("-i")
.arg(&missing)
.args(["-o", dir.path().join("out.fastq").to_str().unwrap()])
.assert()
.failure()
.stderr(predicate::str::contains("opening input"))
.stderr(predicate::str::contains("nonexistent.fastq"));
}
#[test]
fn invalid_whittle_log_falls_back_and_still_reports_the_failure() {
let dir = tempfile::tempdir().unwrap();
let missing = dir.path().join("nonexistent.fastq");
whittle()
.env("WHITTLE_LOG", "garbage=nope=1")
.arg("-i")
.arg(&missing)
.args(["-o", dir.path().join("out.fastq").to_str().unwrap()])
.assert()
.failure()
.stderr(predicate::str::contains("Failed after"))
.stderr(predicate::str::contains("WHITTLE_LOG"))
.stderr(predicate::str::contains("garbage=nope=1"));
}
#[test]
fn dash_means_stdin_and_stdout() {
let dir = tempfile::tempdir().unwrap();
whittle()
.current_dir(dir.path())
.args(["-i", "-", "-o", "-", "--input-format", "fastq", "-l", "5"])
.write_stdin(READS)
.assert()
.success()
.stdout(READS)
.stderr(predicate::str::contains("Input: <stdin>"))
.stderr(predicate::str::contains("Output: <stdout>"));
assert!(
!dir.path().join("-").exists(),
"No file named - may be created"
);
}
#[test]
fn downstream_closing_the_pipe_exits_quietly() {
let dir = tempfile::tempdir().unwrap();
let input = dir.path().join("reads.fastq");
std::fs::write(&input, READS.repeat(40_000)).unwrap();
for threads in [&["-t", "1"][..], &[][..]] {
let mut child = std::process::Command::new(assert_cmd::cargo::cargo_bin("whittle"))
.env_remove("WHITTLE_LOG")
.args(["-i", input.to_str().unwrap()])
.args(threads)
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.unwrap();
let mut stdout = child.stdout.take().unwrap();
let mut head = [0u8; 100];
stdout.read_exact(&mut head).unwrap();
drop(stdout);
let output = child.wait_with_output().unwrap();
let stderr = String::from_utf8_lossy(&output.stderr);
assert!(
output.status.success(),
"A closed pipe exits 0 ({threads:?}): {stderr}"
);
assert!(
!stderr.contains("Failed after"),
"A closed pipe is not reported as a failure ({threads:?}): {stderr}"
);
}
}
#[test]
#[cfg(unix)]
fn hard_linked_input_output_is_rejected_and_preserves_input() {
let dir = tempfile::tempdir().unwrap();
let input = dir.path().join("in.fastq");
let output = dir.path().join("out.fastq");
std::fs::write(&input, "@r1\nACGT\n+\nIIII\n@r2\nTTTT\n+\nIIII\n").unwrap();
std::fs::hard_link(&input, &output).unwrap();
let before = std::fs::read(&input).unwrap();
whittle()
.arg("-i")
.arg(&input)
.arg("-o")
.arg(&output)
.assert()
.failure()
.stderr(predicate::str::contains("same file"));
assert_eq!(
std::fs::read(&input).unwrap(),
before,
"Hard-linked input must be preserved"
);
}
#[test]
fn quiet_suppresses_summary_but_keeps_stdout() {
let input = "@r1\nACGT\n+\nIIII\n";
whittle()
.arg("--quiet")
.write_stdin(input)
.assert()
.success()
.stdout(predicate::str::contains("@r1"))
.stderr(predicate::str::contains("Summary:").not());
}
#[test]
fn default_run_prints_summary_to_stderr() {
let input = "@r1\nACGT\n+\nIIII\n";
whittle().write_stdin(input).assert().success().stderr(
predicate::str::contains("Summary:")
.and(predicate::str::contains("input reads"))
.and(predicate::str::contains("output reads")),
);
}
#[test]
fn over_spec_threads_warns() {
let input = "@r1\nACGT\n+\nIIII\n";
whittle()
.args(["-t", "100000"])
.write_stdin(input)
.assert()
.success()
.stderr(predicate::str::contains("exceeds").and(predicate::str::contains("using")));
}
#[test]
fn verbose_shows_phase_timing() {
let input = "@r1\nACGT\n+\nIIII\n";
whittle()
.arg("-v")
.write_stdin(input)
.assert()
.success()
.stderr(predicate::str::contains("Processing started")); }
#[test]
fn default_hides_debug() {
let input = "@r1\nACGT\n+\nIIII\n";
whittle()
.write_stdin(input)
.assert()
.success()
.stderr(predicate::str::contains("Processing started").not());
}
#[test]
fn quiet_beats_whittle_log() {
let input = "@r1\nACGT\n+\nIIII\n";
whittle()
.env("WHITTLE_LOG", "debug")
.arg("--quiet")
.write_stdin(input)
.assert()
.success()
.stdout(predicate::str::contains("@r1"))
.stderr(predicate::str::contains("Summary:").not());
}
#[test]
fn whittle_log_overrides_verbosity_when_not_quiet() {
let input = "@r1\nACGT\n+\nIIII\n";
whittle()
.env("WHITTLE_LOG", "debug")
.write_stdin(input)
.assert()
.success()
.stderr(predicate::str::contains("Processing started"));
}
#[test]
fn line_mode_banner_and_closer_appear_in_order() {
let input = "@r1\nACGT\n+\nIIII\n";
whittle().write_stdin(input).assert().success().stderr(
predicate::str::contains("whittle ")
.and(predicate::str::contains("Command:"))
.and(predicate::str::contains("Trimming"))
.and(predicate::str::contains("Input: <stdin>"))
.and(predicate::str::contains("Output: <stdout>"))
.and(predicate::str::contains("Threads:"))
.and(predicate::str::contains("Filters:"))
.and(predicate::str::contains("Summary:"))
.and(predicate::str::contains("Completed in")),
);
}
#[test]
fn banner_version_and_command_come_first_in_line_mode() {
let input = "@r1\nACGT\n+\nIIII\n";
let assert = whittle().write_stdin(input).assert().success();
let stderr = String::from_utf8(assert.get_output().stderr.clone()).unwrap();
let version_pos = stderr.find("whittle ").expect("Version line present");
let command_pos = stderr.find("Command:").expect("Command line present");
let operation_pos = stderr.find("Trimming").expect("Operation line present");
assert!(
version_pos < command_pos && command_pos < operation_pos,
"Expected version, then Command:, then the operation line, in order: {stderr:?}"
);
}
#[test]
fn non_tty_stderr_has_no_ansi_escapes() {
let input = "@r1\nACGT\n+\nIIII\n";
whittle()
.write_stdin(input)
.assert()
.success()
.stderr(predicate::str::contains("\u{1b}").not());
}
#[test]
fn all_dropped_run_warns() {
let input = "@r1\nACGT\n+\nIIII\n";
whittle()
.args(["-q", "50", "--input-format", "fastq"])
.write_stdin(input)
.assert()
.success()
.stderr(
predicate::str::contains("No reads survived")
.and(predicate::str::contains("every input read was dropped")),
);
}
#[test]
fn empty_bgzf_stream_is_empty_input() {
let eof_block: &[u8] = &[
0x1f, 0x8b, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x06, 0x00, 0x42, 0x43, 0x02,
0x00, 0x1b, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
];
whittle()
.write_stdin(eof_block)
.assert()
.success()
.stderr(predicate::str::contains("Input contained no reads"));
}
#[test]
fn empty_input_warns() {
whittle()
.args(["--input-format", "fastq"])
.write_stdin("")
.assert()
.success()
.stderr(predicate::str::contains("Input contained no reads"));
}
#[test]
fn sequential_threads_label_for_dash_t_1() {
let input = "@r1\nACGT\n+\nIIII\n";
whittle()
.args(["-t", "1"])
.write_stdin(input)
.assert()
.success()
.stderr(predicate::str::contains("Threads: 1 (sequential)"));
}
#[test]
fn bam_to_fastq_conversion_phrasing() {
use noodles_bam as bam;
use noodles_sam::alignment::RecordBuf;
use noodles_sam::alignment::io::Write as _;
use noodles_sam::alignment::record::Flags;
use noodles_sam::{self as sam};
let dir = tempfile::tempdir().unwrap();
let inp = dir.path().join("in.bam");
let out = dir.path().join("o.fastq");
let header = sam::Header::default();
let mut w = bam::io::Writer::new(std::fs::File::create(&inp).unwrap());
w.write_header(&header).unwrap();
let mut rec = RecordBuf::default();
*rec.flags_mut() = Flags::UNMAPPED;
*rec.name_mut() = Some(b"r1".into());
*rec.sequence_mut() = b"ACGTACGTAC".to_vec().into();
*rec.quality_scores_mut() = vec![40; 10].into();
w.write_alignment_record(&header, &rec).unwrap();
w.try_finish().unwrap();
whittle()
.arg("-i")
.arg(&inp)
.arg("-o")
.arg(&out)
.assert()
.success()
.stderr(predicate::str::contains("Converting BAM to FASTQ"));
}
#[test]
fn gz_output_roundtrips() {
let dir = tempfile::tempdir().unwrap();
let out = dir.path().join("out.fastq.gz");
whittle()
.args(["--input-format", "fastq", "-o"])
.arg(&out)
.write_stdin("@r1\nACGT\n+\nIIII\n")
.assert()
.success();
let mut gz = flate2::read::MultiGzDecoder::new(std::fs::File::open(&out).unwrap());
let mut s = String::new();
gz.read_to_string(&mut s).unwrap();
assert_eq!(s, "@r1\nACGT\n+\nIIII\n");
}
#[test]
fn forced_in_format_is_checked_against_the_stream() {
let dir = tempfile::tempdir().unwrap();
let input = dir.path().join("reads.fastq");
std::fs::write(&input, READS).unwrap();
for (forced, detected) in [
("fastq-bgz", "FASTQ"),
("bam", "FASTQ"),
("fastq-gz", "FASTQ"),
] {
whittle()
.args([
"-i",
input.to_str().unwrap(),
"--input-format",
forced,
"--quiet",
])
.assert()
.failure()
.stderr(predicates::str::contains(format!(
"but the input is {detected}"
)))
.stderr(predicates::str::contains("pass --input-format fastq"));
}
whittle()
.args([
"-i",
input.to_str().unwrap(),
"--input-format",
"fastq",
"--quiet",
])
.assert()
.success()
.stdout(READS);
let empty = dir.path().join("empty.fastq");
std::fs::write(&empty, "").unwrap();
whittle()
.args([
"-i",
empty.to_str().unwrap(),
"--input-format",
"fastq",
"--quiet",
])
.assert()
.success()
.stdout("");
}
#[test]
fn unknown_output_extension_is_reported() {
let dir = tempfile::tempdir().unwrap();
let out = dir.path().join("out.fasta");
whittle()
.args([
"-o",
out.to_str().unwrap(),
"--input-format",
"fastq",
"-l",
"5",
])
.write_stdin(READS)
.assert()
.success()
.stderr(predicates::str::contains(
"extension .fasta names no supported format; writing FASTQ",
));
assert_eq!(std::fs::read_to_string(&out).unwrap(), READS);
}
#[test]
fn fastq_to_bam_is_rejected_before_the_run() {
whittle()
.args(["-i", "reads.fastq", "-o", "out.bam"])
.assert()
.failure()
.code(2)
.stderr(predicates::str::contains(
"FASTQ-to-BAM conversion is not supported",
))
.stderr(predicates::str::contains("Input:").not());
}
#[test]
fn piped_fastq_to_bam_is_rejected_before_the_run() {
whittle()
.args(["-o", "out.bam"])
.write_stdin("@r1\nACGTACGTAC\n+\nIIIIIIIIII\n")
.assert()
.failure()
.stderr(predicates::str::contains(
"FASTQ-to-BAM conversion is not supported (a FASTQ read carries no header",
))
.stderr(predicates::str::contains("Input:").not());
}
#[test]
fn update_moves_requires_bam_input() {
whittle()
.args(["-i", "reads.fastq", "--update-moves"])
.assert()
.failure()
.code(2)
.stderr(predicates::str::contains(
"--update-moves rewrites the ONT signal tags of BAM records and requires BAM input",
));
}
#[test]
fn zero_threads_names_the_floor() {
whittle()
.args(["-t", "0", "--input-format", "fastq"])
.write_stdin(READS)
.assert()
.failure()
.stderr(predicates::str::contains("must be at least 1"))
.stderr(predicates::str::contains("18446744073709551615").not());
}
#[cfg(feature = "paraseq")]
#[test]
fn paraseq_parser_matches_seq_io_on_long_reads() {
let mut fastq = String::new();
for i in 0..40usize {
let seq: String = (0..200_000)
.map(|j| ['A', 'C', 'G', 'T'][(i * 7 + j * j) % 4])
.collect();
fastq.push_str(&format!("@long{i}\n{seq}\n+\n{}\n", "I".repeat(seq.len())));
}
let run = |parser: &str| {
whittle()
.env("WHITTLE_FASTQ_PARSER", parser)
.args(["-t", "4", "--preserve-order", "--quiet", "-H", "5"])
.args(["--input-format", "fastq"])
.write_stdin(fastq.clone())
.assert()
.success()
.get_output()
.stdout
.clone()
};
let paraseq = run("paraseq");
assert_eq!(paraseq.iter().filter(|&&b| b == b'@').count(), 40);
assert!(paraseq == run("seq_io"), "The parsers disagree");
}