use std::fs::File;
use std::io::{self, BufReader, BufWriter, Read, Write};
use anyhow::Context;
use flate2::bufread::MultiGzDecoder;
use noodles_sam::alignment::record_buf::data::field::Value;
use noodles_sam::alignment::record_buf::data::field::value::Array;
use seq_io::fastq::{Reader, Record};
use crate::config::Config;
use crate::record::ReadRecord;
const INPUT_BUFFER_CAPACITY: usize = 1 << 20;
pub fn reader_from(
inner: Box<dyn Read + Send>,
gz: bool,
inflate_thread: bool,
) -> Box<dyn Iterator<Item = anyhow::Result<ReadRecord>> + Send> {
Box::new(RecordIter::new(byte_stream(inner, gz, inflate_thread)))
}
pub fn byte_stream(
inner: Box<dyn Read + Send>,
gz: bool,
inflate_thread: bool,
) -> Box<dyn Read + Send> {
if !gz {
return inner;
}
let decoder = MultiGzDecoder::new(BufReader::with_capacity(INPUT_BUFFER_CAPACITY, inner));
if inflate_thread {
Box::new(InflateThread::spawn(decoder))
} else {
Box::new(decoder)
}
}
const INFLATE_CHUNK: usize = 1 << 20;
const INFLATE_QUEUE: usize = 2;
struct InflateThread {
chunks: std::sync::mpsc::Receiver<io::Result<Vec<u8>>>,
recycle: std::sync::mpsc::Sender<Vec<u8>>,
current: Vec<u8>,
pos: usize,
ended: bool,
failed: bool,
}
impl InflateThread {
fn spawn<D: Read + Send + 'static>(mut decoder: D) -> Self {
let (tx, chunks) = std::sync::mpsc::sync_channel::<io::Result<Vec<u8>>>(INFLATE_QUEUE);
let (recycle, reuse) = std::sync::mpsc::channel::<Vec<u8>>();
std::thread::spawn(move || {
loop {
let mut chunk = reuse
.try_recv()
.unwrap_or_else(|_| Vec::with_capacity(INFLATE_CHUNK));
chunk.resize(INFLATE_CHUNK, 0);
let mut filled = 0;
let mut failure = None;
while filled < chunk.len() {
match decoder.read(&mut chunk[filled..]) {
Ok(0) => break,
Ok(n) => filled += n,
Err(e) if e.kind() == io::ErrorKind::Interrupted => {},
Err(e) => {
failure = Some(e);
break;
},
}
}
chunk.truncate(filled);
let end = filled == 0;
if (filled > 0 || failure.is_none()) && tx.send(Ok(chunk)).is_err() {
return;
}
if let Some(e) = failure {
let _ = tx.send(Err(e));
return;
}
if end {
return;
}
}
});
InflateThread {
chunks,
recycle,
current: Vec::new(),
pos: 0,
ended: false,
failed: false,
}
}
}
impl Read for InflateThread {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
if buf.is_empty() {
return Ok(0);
}
while self.pos == self.current.len() {
if self.failed {
return Err(io::Error::other("the gzip stream failed to decode"));
}
if self.ended {
return Ok(0);
}
let used = std::mem::take(&mut self.current);
if used.capacity() > 0 {
let _ = self.recycle.send(used);
}
self.pos = 0;
match self.chunks.recv() {
Ok(Ok(chunk)) if chunk.is_empty() => self.ended = true,
Ok(Ok(chunk)) => self.current = chunk,
Ok(Err(e)) => {
self.failed = true;
return Err(e);
},
Err(_) => {
self.failed = true;
return Err(io::Error::other(
"the gzip decoder thread stopped before the end of the stream",
));
},
}
}
let n = buf.len().min(self.current.len() - self.pos);
buf[..n].copy_from_slice(&self.current[self.pos..self.pos + n]);
self.pos += n;
Ok(n)
}
}
pub fn reader_from_bgzf(
inner: Box<dyn Read + Send>,
workers: usize,
) -> anyhow::Result<Box<dyn Iterator<Item = anyhow::Result<ReadRecord>> + Send>> {
let inner = BufReader::with_capacity(INPUT_BUFFER_CAPACITY, inner);
let inner: Box<dyn Read + Send> = if workers > 1 {
Box::new(noodles_bgzf::io::MultithreadedReader::with_worker_count(
std::num::NonZero::new(workers).unwrap_or(std::num::NonZero::<usize>::MIN),
inner,
))
} else {
Box::new(noodles_bgzf::io::Reader::new(inner))
};
Ok(Box::new(RecordIter::new(inner)))
}
pub(crate) const MAX_PHRED33: u8 = 126 - 33;
struct RecordIter<R: Read> {
reader: Reader<R>,
count: u64,
last_id: Vec<u8>,
}
impl<R: Read> RecordIter<R> {
fn new(inner: R) -> Self {
RecordIter {
reader: Reader::new(inner),
count: 0,
last_id: Vec::new(),
}
}
fn describe(&self, e: seq_io::fastq::Error) -> anyhow::Error {
match e {
seq_io::fastq::Error::Io(e) => {
let context = if self.count == 0 {
"reading the first FASTQ record".to_string()
} else {
format!(
"reading FASTQ record after {}",
String::from_utf8_lossy(&self.last_id)
)
};
anyhow::Error::new(e).context(context)
},
other => anyhow::Error::new(other),
}
}
}
pub(crate) fn invalid_quality(id: &[u8], qual: &[u8]) -> anyhow::Error {
let (pos, &byte) = qual
.iter()
.enumerate()
.find(|&(_, &b)| b.wrapping_sub(33) > MAX_PHRED33)
.expect("The caller found a quality byte outside the Phred+33 range");
anyhow::anyhow!(
"record {}: quality byte 0x{byte:02x} at position {} is outside the Phred+33 range \
(ASCII 33..=126)",
String::from_utf8_lossy(id),
pos + 1
)
}
impl<R: Read> Iterator for RecordIter<R> {
type Item = anyhow::Result<ReadRecord>;
fn next(&mut self) -> Option<Self::Item> {
let rec = match self.reader.next()? {
Ok(rec) => rec,
Err(e) => return Some(Err(self.describe(e))),
};
let raw = rec.qual();
let mut out_of_range = false;
let qual: Vec<u8> = raw
.iter()
.map(|&b| {
let q = b.wrapping_sub(33);
out_of_range |= q > MAX_PHRED33;
q
})
.collect();
if out_of_range {
return Some(Err(invalid_quality(rec.id_bytes(), raw)));
}
self.count += 1;
self.last_id.clear();
self.last_id.extend_from_slice(rec.id_bytes());
Some(Ok(ReadRecord {
name: rec.head().to_vec(),
seq: rec.seq().to_vec(),
qual,
}))
}
}
pub(crate) fn write_head<W: Write>(
w: &mut W,
name: &[u8],
total_segments: usize,
segment_idx: usize,
) -> io::Result<()> {
w.write_all(b"@")?;
if total_segments > 1 {
match name.iter().position(|&b| b == b' ' || b == b'\t') {
Some(i) => {
w.write_all(&name[..i])?;
write!(w, "_segment_{}", segment_idx + 1)?;
w.write_all(&name[i..])?;
},
None => {
w.write_all(name)?;
write!(w, "_segment_{}", segment_idx + 1)?;
},
}
} else {
w.write_all(name)?;
}
Ok(())
}
pub fn write_segment<W: Write>(
w: &mut W,
name: &[u8],
seq: &[u8],
phred: &[u8],
total_segments: usize,
segment_idx: usize,
) -> io::Result<()> {
write_head(w, name, total_segments, segment_idx)?;
write_body(w, seq, phred)
}
pub(crate) fn push_record_body(out: &mut Vec<u8>, seq: &[u8], phred: &[u8]) {
write_body(out, seq, phred).expect("Writing to a Vec cannot fail");
}
pub(crate) fn write_body<W: Write>(w: &mut W, seq: &[u8], phred: &[u8]) -> io::Result<()> {
w.write_all(b"\n")?;
w.write_all(seq)?;
w.write_all(b"\n+\n")?;
let mut ascii = [0u8; 1024];
for chunk in phred.chunks(ascii.len()) {
for (dst, &q) in ascii.iter_mut().zip(chunk) {
*dst = q.min(MAX_PHRED33) + 33;
}
w.write_all(&ascii[..chunk.len()])?;
}
w.write_all(b"\n")
}
const DIGIT_PAIRS: [[u8; 2]; 100] = {
let mut t = [[0u8; 2]; 100];
let mut i = 0;
while i < 100 {
t[i] = [b'0' + (i / 10) as u8, b'0' + (i % 10) as u8];
i += 1;
}
t
};
#[inline]
pub(crate) fn push_u64(out: &mut Vec<u8>, mut n: u64) {
if n < 10 {
out.push(b'0' + n as u8);
return;
}
if n < 100 {
out.extend_from_slice(&DIGIT_PAIRS[n as usize]);
return;
}
let mut buf = [0u8; 20];
let mut i = buf.len();
loop {
i -= 1;
buf[i] = b'0' + (n % 10) as u8;
n /= 10;
if n == 0 {
break;
}
}
out.extend_from_slice(&buf[i..]);
}
#[inline]
pub(crate) fn push_i64(out: &mut Vec<u8>, n: i64) {
if n < 0 {
out.push(b'-');
}
push_u64(out, n.unsigned_abs());
}
pub fn push_aux_field(out: &mut Vec<u8>, tag: [u8; 2], value: &Value) {
out.extend_from_slice(&tag);
out.push(b':');
match value {
Value::Character(c) => {
out.extend_from_slice(b"A:");
out.push(*c);
},
Value::Int8(n) => {
out.extend_from_slice(b"i:");
push_i64(out, i64::from(*n));
},
Value::UInt8(n) => {
out.extend_from_slice(b"i:");
push_u64(out, u64::from(*n));
},
Value::Int16(n) => {
out.extend_from_slice(b"i:");
push_i64(out, i64::from(*n));
},
Value::UInt16(n) => {
out.extend_from_slice(b"i:");
push_u64(out, u64::from(*n));
},
Value::Int32(n) => {
out.extend_from_slice(b"i:");
push_i64(out, i64::from(*n));
},
Value::UInt32(n) => {
out.extend_from_slice(b"i:");
push_u64(out, u64::from(*n));
},
Value::Float(x) => write!(out, "f:{x}").unwrap(),
Value::String(s) => {
out.extend_from_slice(b"Z:");
out.extend_from_slice(AsRef::<[u8]>::as_ref(s));
},
Value::Hex(s) => {
out.extend_from_slice(b"H:");
out.extend_from_slice(AsRef::<[u8]>::as_ref(s));
},
Value::Array(a) => {
out.extend_from_slice(b"B:");
write_array(out, a);
},
}
}
const COMMA_U8: [([u8; 4], usize); 256] = {
let mut t = [([0u8; 4], 0usize); 256];
let mut i = 0;
while i < 256 {
let n = i as u8;
let mut b = [b',', 0, 0, 0];
let len = if n >= 100 {
b[1] = b'0' + n / 100;
b[2] = b'0' + (n / 10) % 10;
b[3] = b'0' + n % 10;
4
} else if n >= 10 {
b[1] = b'0' + n / 10;
b[2] = b'0' + n % 10;
3
} else {
b[1] = b'0' + n;
2
};
t[i] = (b, len);
i += 1;
}
t
};
const COMMA_I8: [([u8; 5], usize); 256] = {
let mut t = [([0u8; 5], 0usize); 256];
let mut i = 0;
while i < 256 {
let x = i as u8 as i8;
let m = x.unsigned_abs();
let mut b = [b',', 0, 0, 0, 0];
let mut len = 1;
if x < 0 {
b[len] = b'-';
len += 1;
}
if m >= 100 {
b[len] = b'0' + m / 100;
b[len + 1] = b'0' + (m / 10) % 10;
b[len + 2] = b'0' + m % 10;
len += 3;
} else if m >= 10 {
b[len] = b'0' + m / 10;
b[len + 1] = b'0' + m % 10;
len += 2;
} else {
b[len] = b'0' + m;
len += 1;
}
t[i] = (b, len);
i += 1;
}
t
};
fn push_comma_u8s(out: &mut Vec<u8>, v: &[u8]) {
out.reserve(v.len() * 4);
for &x in v {
let (bytes, len) = COMMA_U8[usize::from(x)];
out.extend_from_slice(&bytes);
out.truncate(out.len() - (4 - len));
}
}
fn push_comma_i8s(out: &mut Vec<u8>, v: &[i8]) {
out.reserve(v.len() * 5);
for &x in v {
let (bytes, len) = COMMA_I8[usize::from(x as u8)];
out.extend_from_slice(&bytes);
out.truncate(out.len() - (5 - len));
}
}
fn push_comma_u64s(out: &mut Vec<u8>, v: impl ExactSizeIterator<Item = u64>) {
out.reserve(v.len() * 2);
for x in v {
out.push(b',');
push_u64(out, x);
}
}
fn push_comma_i64s(out: &mut Vec<u8>, v: impl ExactSizeIterator<Item = i64>) {
out.reserve(v.len() * 2);
for x in v {
out.push(b',');
push_i64(out, x);
}
}
fn write_array(out: &mut Vec<u8>, a: &Array) {
match a {
Array::Int8(v) => {
out.push(b'c');
push_comma_i8s(out, v);
},
Array::UInt8(v) => {
out.push(b'C');
push_comma_u8s(out, v);
},
Array::Int16(v) => {
out.push(b's');
push_comma_i64s(out, v.iter().map(|&x| i64::from(x)));
},
Array::UInt16(v) => {
out.push(b'S');
push_comma_u64s(out, v.iter().map(|&x| u64::from(x)));
},
Array::Int32(v) => {
out.push(b'i');
push_comma_i64s(out, v.iter().map(|&x| i64::from(x)));
},
Array::UInt32(v) => {
out.push(b'I');
push_comma_u64s(out, v.iter().map(|&x| u64::from(x)));
},
Array::Float(v) => {
out.push(b'f');
out.reserve(v.len() * 2);
for x in v {
write!(out, ",{x}").unwrap();
}
},
}
}
pub fn push_mods_aux(
out: &mut Vec<u8>,
mm: &[u8],
ml: Option<&[u8]>,
mn: usize,
remove: &crate::config::TagRemoval,
) {
out.reserve(mm.len() + 40);
if !remove.contains(b"MM") {
out.extend_from_slice(b"\tMM:Z:");
out.extend_from_slice(mm);
}
if let Some(ml) = ml
&& !remove.contains(b"ML")
{
out.extend_from_slice(b"\tML:B:C");
push_comma_u8s(out, ml);
}
if !remove.contains(b"MN") {
out.extend_from_slice(b"\tMN:i:");
push_u64(out, mn as u64);
}
}
const OUTPUT_BUFFER_CAPACITY: usize = 1 << 20;
type BufferedOutput = BufWriter<Box<dyn Write + Send>>;
pub(crate) enum FastqOut {
Plain(BufferedOutput),
Bgzf(crate::io::bgzf::Writer<BufferedOutput>),
Blocks {
inner: BufferedOutput,
level: u8,
},
}
impl Write for FastqOut {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
match self {
FastqOut::Plain(w) | FastqOut::Blocks { inner: w, .. } => w.write(buf),
FastqOut::Bgzf(w) => w.write(buf),
}
}
fn flush(&mut self) -> std::io::Result<()> {
match self {
FastqOut::Plain(w) | FastqOut::Blocks { inner: w, .. } => w.flush(),
FastqOut::Bgzf(w) => w.flush(),
}
}
}
impl FastqOut {
pub(crate) fn block_level(&self) -> Option<u8> {
match self {
FastqOut::Blocks { level, .. } => Some(*level),
FastqOut::Plain(_) | FastqOut::Bgzf(_) => None,
}
}
pub(crate) fn finish(self) -> anyhow::Result<()> {
let mut inner = match self {
FastqOut::Plain(w) => w,
FastqOut::Bgzf(w) => w.finish()?,
FastqOut::Blocks { mut inner, .. } => {
inner.write_all(&crate::io::bgzf::EOF_BLOCK)?;
inner
},
};
inner.flush()?;
Ok(())
}
}
pub(crate) fn encode_blocks(level: u8, data: &[u8]) -> std::io::Result<Vec<u8>> {
let mut blocks = Vec::new();
crate::io::bgzf::encode(level, data, &mut blocks)?;
Ok(blocks)
}
pub(crate) fn writer(
cfg: &Config,
out_fmt: crate::io::Format,
parallel: bool,
) -> anyhow::Result<FastqOut> {
writer_to(
cfg.io.output.as_deref(),
out_fmt,
cfg.compression_level,
parallel,
)
}
pub(crate) fn writer_to(
path: Option<&std::path::Path>,
out_fmt: crate::io::Format,
level: u8,
parallel: bool,
) -> anyhow::Result<FastqOut> {
let inner: Box<dyn Write + Send> = match path {
Some(p) => {
Box::new(File::create(p).with_context(|| format!("creating output {}", p.display()))?)
},
None => Box::new(io::stdout()),
};
let base = BufWriter::with_capacity(OUTPUT_BUFFER_CAPACITY, inner);
match out_fmt {
crate::io::Format::FastqGz | crate::io::Format::FastqBgzf => {
crate::io::bgzf::compression_level(level)?;
if parallel {
return Ok(FastqOut::Blocks { inner: base, level });
}
Ok(FastqOut::Bgzf(crate::io::bgzf::Writer::new(base, level)))
},
crate::io::Format::Fastq => Ok(FastqOut::Plain(base)),
crate::io::Format::Bam => unreachable!("BAM output is written by `io::bam::writer`"),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn qualities_above_the_fastq_range_are_clamped() {
let mut out = Vec::new();
write_body(&mut out, b"ACGT", &[0, 93, 94, 255]).unwrap();
assert_eq!(out, b"\nACGT\n+\n!~~~\n");
}
#[test]
fn writes_single_segment_verbatim_header() {
let mut out = Vec::new();
write_segment(&mut out, b"read1 desc", b"ACGT", &[40, 40, 40, 40], 1, 0).unwrap();
assert_eq!(out, b"@read1 desc\nACGT\n+\nIIII\n");
}
#[test]
fn split_segment_suffixes_id_before_desc() {
let mut out = Vec::new();
write_segment(&mut out, b"read1 desc", b"AC", &[40, 40], 2, 1).unwrap();
assert_eq!(out, b"@read1_segment_2 desc\nAC\n+\nII\n");
}
#[test]
fn split_segment_preserves_tab_delimited_tags() {
let mut out = Vec::new();
write_segment(&mut out, b"r1\tRG:Z:grp", b"AC", &[40, 40], 2, 0).unwrap();
assert_eq!(out, b"@r1_segment_1\tRG:Z:grp\nAC\n+\nII\n");
}
#[test]
fn roundtrip_reader_writer() {
let fq = b"@r1\nACGT\n+\nIIII\n@r2 x\nTT\n+\n!!\n";
let recs: Vec<ReadRecord> = RecordIter::new(&fq[..]).map(|r| r.unwrap()).collect();
assert_eq!(recs.len(), 2);
assert_eq!(recs[0].name, b"r1");
assert_eq!(recs[0].seq, b"ACGT");
assert_eq!(recs[0].qual, vec![40, 40, 40, 40]); assert_eq!(recs[1].qual, vec![0, 0]); }
#[test]
fn quality_range_bounds_are_accepted() {
let fq = b"@r1\nAC\n+\n!~\n";
let recs: Vec<ReadRecord> = RecordIter::new(&fq[..]).map(|r| r.unwrap()).collect();
assert_eq!(recs[0].qual, vec![0, 93]);
}
#[test]
fn quality_byte_outside_phred33_range_is_an_error() {
let fq = b"@r1 desc\nACGTACGT\n+\nII I\x01III\n";
let err = RecordIter::new(&fq[..])
.next()
.unwrap()
.unwrap_err()
.to_string();
assert!(err.contains("record r1"), "Names the record id: {err}");
assert!(
err.contains("0x20"),
"Names the first offending byte: {err}"
);
assert!(err.contains("Phred+33"), "Names the expected range: {err}");
let fq = b"@r2\nAC\n+\nI\x7f\n";
let err = RecordIter::new(&fq[..])
.next()
.unwrap()
.unwrap_err()
.to_string();
assert!(err.contains("record r2") && err.contains("0x7f"), "{err}");
}
struct FailAfter {
data: Vec<u8>,
pos: usize,
msg: &'static str,
}
impl Read for FailAfter {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
if self.pos == self.data.len() {
return Err(io::Error::other(self.msg));
}
let n = (self.data.len() - self.pos).min(buf.len());
buf[..n].copy_from_slice(&self.data[self.pos..self.pos + n]);
self.pos += n;
Ok(n)
}
}
#[test]
fn io_error_carries_record_context_and_prints_the_cause_once() {
let mut data = Vec::new();
for i in 0..8000 {
data.extend_from_slice(format!("@r{i} desc\nACGT\n+\nIIII\n").as_bytes());
}
let mut it = RecordIter::new(FailAfter {
data,
pos: 0,
msg: "incomplete deflate stream",
});
let mut last_id = None;
let err = loop {
match it.next().unwrap() {
Ok(rec) => last_id = Some(rec.name[..rec.name.len() - 5].to_vec()),
Err(e) => break e,
}
};
let last_id = String::from_utf8(last_id.expect("Records precede the error")).unwrap();
assert_eq!(
format!("{err:#}"),
format!("reading FASTQ record after {last_id}: incomplete deflate stream")
);
let mut it = RecordIter::new(FailAfter {
data: Vec::new(),
pos: 0,
msg: "boom",
});
let err = it.next().unwrap().unwrap_err();
assert_eq!(format!("{err:#}"), "reading the first FASTQ record: boom");
}
fn gzip(text: &[u8]) -> Vec<u8> {
let mut enc = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::fast());
enc.write_all(text).unwrap();
enc.finish().unwrap()
}
fn fastq_records(prefix: &str, n: usize) -> Vec<u8> {
let mut text = Vec::new();
for i in 0..n {
text.extend_from_slice(format!("@{prefix}{i}\nACGTACGTAC\n+\nIIIIIIIIII\n").as_bytes());
}
text
}
fn gz_names(gz: Vec<u8>, inflate_thread: bool) -> anyhow::Result<Vec<Vec<u8>>> {
reader_from(Box::new(io::Cursor::new(gz)), true, inflate_thread)
.map(|r| r.map(|r| r.name))
.collect()
}
#[test]
fn inflate_thread_reads_every_gzip_member() {
let mut gz = gzip(&fastq_records("a", 60_000));
gz.extend(gzip(b""));
gz.extend(gzip(&fastq_records("b", 3)));
let names = gz_names(gz.clone(), true).unwrap();
assert_eq!(names.len(), 60_003);
assert_eq!(names[60_000], b"b0");
assert_eq!(names, gz_names(gz, false).unwrap());
}
#[test]
fn inflate_thread_reports_damaged_gzip() {
let gz = gzip(&fastq_records("r", 60_000));
let truncated = gz[..gz.len() / 2].to_vec();
for inflate_thread in [false, true] {
let mut it = reader_from(
Box::new(io::Cursor::new(truncated.clone())),
true,
inflate_thread,
);
let mut read = 0;
let err = loop {
match it.next().expect("The stream ends with an error") {
Ok(_) => read += 1,
Err(e) => break e,
}
};
assert!(read > 0);
assert!(
format!("{err:#}").starts_with("reading FASTQ record after r"),
"{err:#}"
);
}
let mut corrupt = gzip(&fastq_records("r", 10));
corrupt[12..20].copy_from_slice(b"\xff\xff\xff\xff\xff\xff\xff\xff");
let inline = gz_names(corrupt.clone(), false).unwrap_err();
let threaded = gz_names(corrupt, true).unwrap_err();
assert_eq!(format!("{threaded:#}"), format!("{inline:#}"));
assert!(
format!("{threaded:#}").starts_with("reading the first FASTQ record: "),
"{threaded:#}"
);
}
#[test]
fn parse_error_message_is_not_duplicated() {
let fq = b"@r1\nACGT\n+\nII\n";
let err = RecordIter::new(&fq[..]).next().unwrap().unwrap_err();
let msg = format!("{err:#}");
assert_eq!(msg.matches("FASTQ parse error").count(), 1, "{msg}");
}
#[test]
fn gz_writer_clamps_zero_workers_and_writes_bgzf() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("o.fastq.gz");
let mut cfg = crate::cli::config_for_test(&path, &path, 0, 0);
cfg.io.output = Some(path.clone());
let mut w = writer(&cfg, crate::io::Format::FastqGz, false).unwrap();
w.write_all(b"@r1\nACGT\n+\nIIII\n").unwrap();
w.finish().unwrap();
assert!(crate::io::is_bgzf_file(&path));
let mut text = String::new();
MultiGzDecoder::new(BufReader::new(std::fs::File::open(&path).unwrap()))
.read_to_string(&mut text)
.unwrap();
assert_eq!(text, "@r1\nACGT\n+\nIIII\n");
}
#[test]
fn bgzf_reader_roundtrips_fastq() {
let fq = b"@r1\nACGT\n+\nIIII\n@r2 x\nTT\n+\n!!\n";
let mut writer = noodles_bgzf::io::Writer::new(Vec::new());
writer.write_all(fq).unwrap();
let compressed = writer.finish().unwrap();
let records: Vec<_> = reader_from_bgzf(Box::new(std::io::Cursor::new(compressed)), 1)
.unwrap()
.map(Result::unwrap)
.collect();
assert_eq!(records.len(), 2);
assert_eq!(records[0].name, b"r1");
assert_eq!(records[0].seq, b"ACGT");
assert_eq!(records[1].name, b"r2 x");
}
use noodles_sam::alignment::record_buf::data::field::Value;
use noodles_sam::alignment::record_buf::data::field::value::Array;
fn aux(tag: [u8; 2], value: &Value) -> Vec<u8> {
let mut out = Vec::new();
push_aux_field(&mut out, tag, value);
out
}
fn mods_aux(
mm: &[u8],
ml: Option<&[u8]>,
mn: usize,
remove: &crate::config::TagRemoval,
) -> Vec<u8> {
let mut out = Vec::new();
push_mods_aux(&mut out, mm, ml, mn, remove);
out
}
#[test]
fn aux_scalar_types() {
assert_eq!(
aux(*b"RG", &Value::String(b"grp1".as_slice().into())),
b"RG:Z:grp1"
);
assert_eq!(aux(*b"NM", &Value::Int32(-3)), b"NM:i:-3");
assert_eq!(aux(*b"Uq", &Value::UInt8(200)), b"Uq:i:200");
assert_eq!(aux(*b"pa", &Value::Float(0.5)), b"pa:f:0.5");
assert_eq!(aux(*b"bc", &Value::Character(b'K')), b"bc:A:K");
assert_eq!(
aux(*b"H2", &Value::Hex(b"1AE3".as_slice().into())),
b"H2:H:1AE3"
);
assert_eq!(aux(*b"i1", &Value::Int8(-5)), b"i1:i:-5");
assert_eq!(aux(*b"i2", &Value::Int16(-300)), b"i2:i:-300");
assert_eq!(aux(*b"i3", &Value::UInt16(400)), b"i3:i:400");
assert_eq!(aux(*b"i4", &Value::UInt32(70000)), b"i4:i:70000");
}
#[test]
fn aux_array_subtypes() {
assert_eq!(
aux(*b"a1", &Value::Array(Array::UInt8(vec![1, 2, 3]))),
b"a1:B:C,1,2,3"
);
assert_eq!(
aux(*b"a2", &Value::Array(Array::Int8(vec![-1, 2]))),
b"a2:B:c,-1,2"
);
assert_eq!(
aux(*b"a3", &Value::Array(Array::Int16(vec![-5]))),
b"a3:B:s,-5"
);
assert_eq!(
aux(*b"a4", &Value::Array(Array::UInt16(vec![5]))),
b"a4:B:S,5"
);
assert_eq!(
aux(*b"a5", &Value::Array(Array::Int32(vec![7]))),
b"a5:B:i,7"
);
assert_eq!(
aux(*b"a6", &Value::Array(Array::UInt32(vec![8]))),
b"a6:B:I,8"
);
assert_eq!(
aux(*b"a7", &Value::Array(Array::Float(vec![1.5]))),
b"a7:B:f,1.5"
);
}
#[test]
fn comma_element_tables_match_the_digit_loop() {
let all: Vec<u8> = (0..=255).collect();
let mut fast = Vec::new();
push_comma_u8s(&mut fast, &all);
let mut slow = Vec::new();
push_comma_u64s(&mut slow, all.iter().map(|&x| u64::from(x)));
assert_eq!(fast, slow);
let all: Vec<i8> = (-128..=127).collect();
let mut fast = Vec::new();
push_comma_i8s(&mut fast, &all);
let mut slow = Vec::new();
push_comma_i64s(&mut slow, all.iter().map(|&x| i64::from(x)));
assert_eq!(fast, slow);
}
#[test]
fn push_u64_matches_fmt() {
for n in (0..1200).chain([9_999, 10_000, u64::from(u32::MAX), u64::MAX]) {
let mut out = Vec::new();
push_u64(&mut out, n);
assert_eq!(out, n.to_string().as_bytes(), "{n}");
}
let mut out = Vec::new();
push_i64(&mut out, i64::MIN);
assert_eq!(out, i64::MIN.to_string().as_bytes());
}
#[test]
fn mods_aux_layout() {
let keep = crate::config::TagRemoval::default();
assert_eq!(
mods_aux(b"C+m,0;", Some(&[10, 20]), 6, &keep),
b"\tMM:Z:C+m,0;\tML:B:C,10,20\tMN:i:6"
);
assert_eq!(
mods_aux(b"C+m;", Some(&[]), 4, &keep),
b"\tMM:Z:C+m;\tML:B:C\tMN:i:4"
);
assert_eq!(
mods_aux(b"C+m,0;", None, 4, &keep),
b"\tMM:Z:C+m,0;\tMN:i:4"
);
let removal = |tag: &str| crate::config::TagRemoval::parse(&[tag.to_string()]).unwrap();
assert_eq!(
mods_aux(b"C+m,0;", Some(&[10]), 6, &removal("ML")),
b"\tMM:Z:C+m,0;\tMN:i:6"
);
assert_eq!(
mods_aux(b"C+m,0;", Some(&[10]), 6, &removal("MN")),
b"\tMM:Z:C+m,0;\tML:B:C,10"
);
assert_eq!(
mods_aux(b"C+m,0;", Some(&[10]), 6, &removal("MM")),
b"\tML:B:C,10\tMN:i:6"
);
}
}