Skip to main content

rsomics_call/
alignment.rs

1use std::cmp::Ordering;
2use std::collections::{BinaryHeap, VecDeque};
3use std::fs::File;
4use std::io::{self, BufReader, Read};
5use std::path::{Path, PathBuf};
6
7use noodles::core::Region;
8use noodles::sam::alignment::{Record, RecordBuf};
9use noodles::sam::header::record::value::map::read_group::tag;
10use noodles::{bam, bgzf, cram, fasta, sam};
11use rsomics_bamio::raw::{self, RawRecord, RawRecordEncoder};
12use rsomics_bamio::{IndexedAlignmentReader, open_indexed_alignment};
13
14use crate::{CallError, Result, SampleMap, SampleMapBuilder, SampleSelection};
15
16#[derive(Clone, Debug, PartialEq, Eq)]
17pub struct AlignmentInput {
18    source_id: u32,
19    path: PathBuf,
20    sample_name: Box<str>,
21    ignore_read_groups: bool,
22}
23
24impl AlignmentInput {
25    pub fn new(source_id: u32, path: impl Into<PathBuf>, sample_name: impl Into<Box<str>>) -> Self {
26        Self {
27            source_id,
28            path: path.into(),
29            sample_name: sample_name.into(),
30            ignore_read_groups: false,
31        }
32    }
33
34    pub fn ignore_read_groups(mut self, ignore: bool) -> Self {
35        self.ignore_read_groups = ignore;
36        self
37    }
38
39    pub fn source_id(&self) -> u32 {
40        self.source_id
41    }
42
43    pub fn path(&self) -> &Path {
44        &self.path
45    }
46
47    pub fn sample_name(&self) -> &str {
48        &self.sample_name
49    }
50}
51
52#[derive(Clone, Debug, PartialEq, Eq)]
53pub struct ReferenceSequence {
54    name: Box<[u8]>,
55    length: u64,
56}
57
58impl ReferenceSequence {
59    pub fn name(&self) -> &[u8] {
60        &self.name
61    }
62
63    pub fn length(&self) -> u64 {
64        self.length
65    }
66}
67
68pub struct AlignmentSet {
69    readers: Vec<SourceReader>,
70    pending: BinaryHeap<PendingRecord>,
71    references: Box<[ReferenceSequence]>,
72    samples: SampleMap,
73}
74
75impl AlignmentSet {
76    pub fn open(
77        inputs: impl IntoIterator<Item = AlignmentInput>,
78        reference: Option<&Path>,
79        selection: SampleSelection,
80    ) -> Result<Self> {
81        let repository = reference.map(reference_repository).transpose()?;
82        let mut readers = Vec::new();
83        let mut metadata = AlignmentMetadataBuilder::new(selection);
84
85        for input in inputs {
86            let reader = SourceReader::open(input, repository.clone())?;
87            metadata.add_source(
88                reader.source_id,
89                &reader.path,
90                &reader.header,
91                reader.sample_name.clone(),
92                reader.ignore_read_groups,
93            )?;
94            readers.push(reader);
95        }
96
97        if readers.is_empty() {
98            return Err(CallError::MissingAlignmentInputs);
99        }
100        let (references, samples) = metadata.finish()?;
101
102        let mut set = Self {
103            readers,
104            pending: BinaryHeap::new(),
105            references,
106            samples,
107        };
108        for source_index in 0..set.readers.len() {
109            set.fill_source(source_index)?;
110        }
111        Ok(set)
112    }
113
114    pub fn reference_sequences(&self) -> &[ReferenceSequence] {
115        &self.references
116    }
117
118    pub fn samples(&self) -> &SampleMap {
119        &self.samples
120    }
121
122    pub fn next_record(&mut self) -> Result<Option<(u32, RawRecord)>> {
123        let Some(pending) = self.pending.pop() else {
124            return Ok(None);
125        };
126        let source_id = self.readers[pending.source_index].source_id;
127        self.fill_source(pending.source_index)?;
128        Ok(Some((source_id, pending.record)))
129    }
130
131    fn fill_source(&mut self, source_index: usize) -> Result<()> {
132        if let Some(record) = self.readers[source_index].next_record()? {
133            self.pending.push(PendingRecord::new(source_index, record));
134        }
135        Ok(())
136    }
137}
138
139pub(crate) struct IndexedAlignmentSet {
140    readers: Vec<IndexedSourceReader>,
141    references: Box<[ReferenceSequence]>,
142    samples: SampleMap,
143}
144
145impl IndexedAlignmentSet {
146    pub(crate) fn open(
147        inputs: impl IntoIterator<Item = AlignmentInput>,
148        reference: Option<&Path>,
149        selection: SampleSelection,
150    ) -> Result<Self> {
151        let mut readers = Vec::new();
152        let mut metadata = AlignmentMetadataBuilder::new(selection);
153
154        for input in inputs {
155            let mut reader = open_indexed_alignment(&input.path, reference)
156                .map_err(|error| input_error(&input.path, error))?;
157            let header = reader
158                .read_header()
159                .map_err(|error| input_error(&input.path, error))?;
160            metadata.add_source(
161                input.source_id,
162                &input.path,
163                &header,
164                input.sample_name.clone(),
165                input.ignore_read_groups,
166            )?;
167            readers.push(IndexedSourceReader {
168                source_id: input.source_id,
169                path: input.path,
170                header,
171                reader,
172            });
173        }
174
175        if readers.is_empty() {
176            return Err(CallError::MissingAlignmentInputs);
177        }
178        let (references, samples) = metadata.finish()?;
179        Ok(Self {
180            readers,
181            references,
182            samples,
183        })
184    }
185
186    pub(crate) fn reference_sequences(&self) -> &[ReferenceSequence] {
187        &self.references
188    }
189
190    pub(crate) fn samples(&self) -> &SampleMap {
191        &self.samples
192    }
193
194    pub(crate) fn visit_region(
195        &mut self,
196        region: &Region,
197        mut visit: impl FnMut(&SampleMap, u32, RawRecord) -> Result<()>,
198    ) -> Result<()> {
199        let samples = &self.samples;
200        let mut readers = self
201            .readers
202            .iter_mut()
203            .map(|source| RegionSourceReader::new(source, region))
204            .collect::<Result<Vec<_>>>()?;
205        let mut pending = BinaryHeap::new();
206        for source_index in 0..readers.len() {
207            fill_region_source(&mut readers, &mut pending, source_index)?;
208        }
209        while let Some(record) = pending.pop() {
210            let source_id = readers[record.source_index].source_id;
211            fill_region_source(&mut readers, &mut pending, record.source_index)?;
212            visit(samples, source_id, record.record)?;
213        }
214        Ok(())
215    }
216}
217
218struct IndexedSourceReader {
219    source_id: u32,
220    path: PathBuf,
221    header: sam::Header,
222    reader: IndexedAlignmentReader,
223}
224
225struct RegionSourceReader<'a> {
226    source_id: u32,
227    path: &'a Path,
228    header: &'a sam::Header,
229    records: Box<dyn Iterator<Item = io::Result<Box<dyn Record>>> + 'a>,
230    encoder: RawRecordEncoder,
231}
232
233impl<'a> RegionSourceReader<'a> {
234    fn new(source: &'a mut IndexedSourceReader, region: &Region) -> Result<Self> {
235        let records = source
236            .reader
237            .query(&source.header, region)
238            .map_err(|error| input_error(&source.path, error))?;
239        Ok(Self {
240            source_id: source.source_id,
241            path: &source.path,
242            header: &source.header,
243            records: Box::new(records),
244            encoder: RawRecordEncoder::default(),
245        })
246    }
247
248    fn next_record(&mut self) -> Result<Option<RawRecord>> {
249        let Some(record) = self.records.next() else {
250            return Ok(None);
251        };
252        let record = record.map_err(|error| input_error(self.path, error))?;
253        self.encoder
254            .encode(self.header, record.as_ref())
255            .map(Some)
256            .map_err(|error| input_error(self.path, error))
257    }
258}
259
260fn fill_region_source(
261    readers: &mut [RegionSourceReader<'_>],
262    pending: &mut BinaryHeap<PendingRecord>,
263    source_index: usize,
264) -> Result<()> {
265    if let Some(record) = readers[source_index].next_record()? {
266        pending.push(PendingRecord::new(source_index, record));
267    }
268    Ok(())
269}
270
271struct AlignmentMetadataBuilder {
272    references: Option<Vec<ReferenceSequence>>,
273    samples: SampleMapBuilder,
274}
275
276impl AlignmentMetadataBuilder {
277    fn new(selection: SampleSelection) -> Self {
278        Self {
279            references: None,
280            samples: SampleMapBuilder::new(selection),
281        }
282    }
283
284    fn add_source(
285        &mut self,
286        source_id: u32,
287        path: &Path,
288        header: &sam::Header,
289        sample_name: Box<str>,
290        ignore_read_groups: bool,
291    ) -> Result<()> {
292        let current_references = reference_sequences(header);
293        if let Some(expected) = &self.references {
294            if expected != &current_references {
295                return Err(CallError::ReferenceDictionaryMismatch(
296                    path.display().to_string(),
297                ));
298            }
299        } else {
300            self.references = Some(current_references);
301        }
302
303        let read_groups = header
304            .read_groups()
305            .iter()
306            .filter_map(|(id, group)| {
307                group
308                    .other_fields()
309                    .get(&tag::SAMPLE)
310                    .map(|sample| (id, sample))
311            })
312            .map(|(id, sample)| {
313                let sample = std::str::from_utf8(sample.as_ref())
314                    .map_err(|error| input_error(path, error))?;
315                Ok((id.to_vec(), sample.to_owned()))
316            })
317            .collect::<Result<Vec<_>>>()?;
318        self.samples
319            .add_source(source_id, sample_name, ignore_read_groups, read_groups)
320    }
321
322    fn finish(self) -> Result<(Box<[ReferenceSequence]>, SampleMap)> {
323        Ok((
324            self.references.unwrap().into_boxed_slice(),
325            self.samples.finish()?,
326        ))
327    }
328}
329
330struct SourceReader {
331    source_id: u32,
332    path: PathBuf,
333    sample_name: Box<str>,
334    ignore_read_groups: bool,
335    header: sam::Header,
336    inner: SourceInner,
337}
338
339impl SourceReader {
340    fn open(input: AlignmentInput, repository: Option<fasta::Repository>) -> Result<Self> {
341        let (format, compression) = detect_source(&input.path)?;
342        let file = File::open(&input.path).map_err(|error| input_error(&input.path, error))?;
343        let mut inner = match (format, compression) {
344            (Format::Sam, Compression::None) => SourceInner::Sam {
345                reader: sam::io::Reader::new(BufReader::new(file)),
346                record: RecordBuf::default(),
347                encoder: RawRecordEncoder::default(),
348            },
349            (Format::Sam, Compression::Bgzf) => SourceInner::SamGz {
350                reader: sam::io::Reader::new(bgzf::io::Reader::new(BufReader::new(file))),
351                record: RecordBuf::default(),
352                encoder: RawRecordEncoder::default(),
353            },
354            (Format::Bam, Compression::None) => {
355                SourceInner::BamRaw(bam::io::Reader::from(BufReader::new(file)))
356            }
357            (Format::Bam, Compression::Bgzf) => {
358                SourceInner::Bam(bam::io::Reader::new(BufReader::new(file)))
359            }
360            (Format::Cram, Compression::None) => {
361                let repository = repository.unwrap_or_default();
362                let reader = cram::io::reader::Builder::default()
363                    .set_reference_sequence_repository(repository.clone())
364                    .build_from_reader(BufReader::new(file));
365                SourceInner::Cram {
366                    reader,
367                    repository,
368                    container: cram::io::reader::Container::default(),
369                    records: VecDeque::new(),
370                    encoder: RawRecordEncoder::default(),
371                }
372            }
373            (Format::Cram, Compression::Bgzf) => unreachable!(),
374        };
375        let header = inner
376            .read_header()
377            .map_err(|error| input_error(&input.path, error))?;
378
379        Ok(Self {
380            source_id: input.source_id,
381            path: input.path,
382            sample_name: input.sample_name,
383            ignore_read_groups: input.ignore_read_groups,
384            header,
385            inner,
386        })
387    }
388
389    fn next_record(&mut self) -> Result<Option<RawRecord>> {
390        self.inner
391            .next_record(&self.header)
392            .map_err(|error| input_error(&self.path, error))
393    }
394}
395
396enum SourceInner {
397    Sam {
398        reader: sam::io::Reader<BufReader<File>>,
399        record: RecordBuf,
400        encoder: RawRecordEncoder,
401    },
402    SamGz {
403        reader: sam::io::Reader<bgzf::io::Reader<BufReader<File>>>,
404        record: RecordBuf,
405        encoder: RawRecordEncoder,
406    },
407    Bam(bam::io::Reader<bgzf::io::Reader<BufReader<File>>>),
408    BamRaw(bam::io::Reader<BufReader<File>>),
409    Cram {
410        reader: cram::io::Reader<BufReader<File>>,
411        repository: fasta::Repository,
412        container: cram::io::reader::Container,
413        records: VecDeque<RecordBuf>,
414        encoder: RawRecordEncoder,
415    },
416}
417
418impl SourceInner {
419    fn read_header(&mut self) -> std::io::Result<sam::Header> {
420        match self {
421            Self::Sam { reader, .. } => reader.read_header(),
422            Self::SamGz { reader, .. } => reader.read_header(),
423            Self::Bam(reader) => reader.read_header(),
424            Self::BamRaw(reader) => reader.read_header(),
425            Self::Cram { reader, .. } => reader.read_header(),
426        }
427    }
428
429    fn next_record(&mut self, header: &sam::Header) -> std::io::Result<Option<RawRecord>> {
430        match self {
431            Self::Sam {
432                reader,
433                record,
434                encoder,
435            } => {
436                if reader.read_record_buf(header, record)? == 0 {
437                    Ok(None)
438                } else {
439                    encode_record(encoder, header, record).map(Some)
440                }
441            }
442            Self::SamGz {
443                reader,
444                record,
445                encoder,
446            } => {
447                if reader.read_record_buf(header, record)? == 0 {
448                    Ok(None)
449                } else {
450                    encode_record(encoder, header, record).map(Some)
451                }
452            }
453            Self::Bam(reader) => read_bam_record(reader.get_mut()),
454            Self::BamRaw(reader) => read_bam_record(reader.get_mut()),
455            Self::Cram {
456                reader,
457                repository,
458                container,
459                records,
460                encoder,
461            } => {
462                while records.is_empty() {
463                    if reader.read_container(container)? == 0 {
464                        return Ok(None);
465                    }
466                    let compression_header = container.compression_header()?;
467                    for slice in container.slices() {
468                        let slice = slice?;
469                        let (core, external) = slice.decode_blocks()?;
470                        let decoded = slice.records(
471                            repository.clone(),
472                            header,
473                            &compression_header,
474                            &core,
475                            &external,
476                        )?;
477                        for record in decoded {
478                            records
479                                .push_back(RecordBuf::try_from_alignment_record(header, &record)?);
480                        }
481                    }
482                }
483                encode_record(encoder, header, &records.pop_front().unwrap()).map(Some)
484            }
485        }
486    }
487}
488
489fn encode_record(
490    encoder: &mut RawRecordEncoder,
491    header: &sam::Header,
492    record: &dyn sam::alignment::Record,
493) -> io::Result<RawRecord> {
494    encoder
495        .encode(header, record)
496        .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
497}
498
499struct PendingRecord {
500    source_index: usize,
501    coordinate: (i32, i32),
502    record: RawRecord,
503}
504
505impl PendingRecord {
506    fn new(source_index: usize, record: RawRecord) -> Self {
507        let coordinate = if record.flags() & 0x04 != 0 {
508            (i32::MAX, i32::MAX)
509        } else {
510            (record.reference_sequence_id(), record.alignment_start())
511        };
512        Self {
513            source_index,
514            coordinate,
515            record,
516        }
517    }
518}
519
520impl PartialEq for PendingRecord {
521    fn eq(&self, other: &Self) -> bool {
522        (self.coordinate, self.source_index) == (other.coordinate, other.source_index)
523    }
524}
525
526impl Eq for PendingRecord {}
527
528impl PartialOrd for PendingRecord {
529    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
530        Some(self.cmp(other))
531    }
532}
533
534impl Ord for PendingRecord {
535    fn cmp(&self, other: &Self) -> Ordering {
536        (other.coordinate, other.source_index).cmp(&(self.coordinate, self.source_index))
537    }
538}
539
540#[derive(Clone, Copy)]
541enum Format {
542    Sam,
543    Bam,
544    Cram,
545}
546
547#[derive(Clone, Copy)]
548enum Compression {
549    None,
550    Bgzf,
551}
552
553fn detect_source(path: &Path) -> Result<(Format, Compression)> {
554    let mut source = BufReader::new(File::open(path).map_err(|error| input_error(path, error))?);
555    let mut magic = [0; 4];
556    source
557        .read_exact(&mut magic)
558        .map_err(|error| input_error(path, error))?;
559    if magic == *b"CRAM" {
560        return Ok((Format::Cram, Compression::None));
561    }
562    if magic == *b"BAM\x01" {
563        return Ok((Format::Bam, Compression::None));
564    }
565    if magic[..2] != [0x1f, 0x8b] {
566        return Ok((Format::Sam, Compression::None));
567    }
568
569    let file = File::open(path).map_err(|error| input_error(path, error))?;
570    let mut reader = bgzf::io::Reader::new(file);
571    reader
572        .read_exact(&mut magic)
573        .map_err(|error| input_error(path, error))?;
574    Ok((
575        if magic == *b"BAM\x01" {
576            Format::Bam
577        } else {
578            Format::Sam
579        },
580        Compression::Bgzf,
581    ))
582}
583
584fn reference_repository(path: &Path) -> Result<fasta::Repository> {
585    fasta::io::indexed_reader::Builder::default()
586        .build_from_path(path)
587        .map(fasta::repository::adapters::IndexedReader::new)
588        .map(fasta::Repository::new)
589        .map_err(|error| input_error(path, error))
590}
591
592fn reference_sequences(header: &sam::Header) -> Vec<ReferenceSequence> {
593    header
594        .reference_sequences()
595        .iter()
596        .map(|(name, reference)| ReferenceSequence {
597            name: name.to_vec().into_boxed_slice(),
598            length: usize::from(reference.length()) as u64,
599        })
600        .collect()
601}
602
603fn read_bam_record(reader: &mut impl Read) -> std::io::Result<Option<RawRecord>> {
604    let mut record = RawRecord::default();
605    match raw::read_record(reader, &mut record) {
606        Ok(0) => Ok(None),
607        Ok(_) => Ok(Some(record)),
608        Err(error) => Err(std::io::Error::new(std::io::ErrorKind::InvalidData, error)),
609    }
610}
611
612fn input_error(path: &Path, error: impl std::fmt::Display) -> CallError {
613    CallError::AlignmentInput {
614        path: path.display().to_string(),
615        message: error.to_string(),
616    }
617}
618
619#[cfg(test)]
620mod tests {
621    use std::io::Write;
622
623    use noodles::sam::alignment::io::Write as _;
624    use tempfile::NamedTempFile;
625
626    use super::*;
627
628    const FIRST: &str = "@HD\tVN:1.6\tSO:coordinate\n\
629@SQ\tSN:chr1\tLN:20\n\
630@RG\tID:rg1\tSM:S1\n\
631r1\t0\tchr1\t3\t60\t1M\t*\t0\t0\tA\tI\tRG:Z:rg1\n";
632    const SECOND: &str = "@HD\tVN:1.6\tSO:coordinate\n\
633@SQ\tSN:chr1\tLN:20\n\
634@RG\tID:rg2\tSM:S2\n\
635r2\t0\tchr1\t2\t60\t1M\t*\t0\t0\tG\tI\tRG:Z:rg2\n";
636
637    fn sam_file(contents: &str) -> NamedTempFile {
638        let mut file = NamedTempFile::new().unwrap();
639        file.write_all(contents.as_bytes()).unwrap();
640        file
641    }
642
643    fn bam_file(contents: &str) -> NamedTempFile {
644        let mut reader = sam::io::Reader::new(contents.as_bytes());
645        let header = reader.read_header().unwrap();
646        let records = reader
647            .record_bufs(&header)
648            .collect::<std::io::Result<Vec<_>>>()
649            .unwrap();
650        let file = NamedTempFile::new().unwrap();
651        let mut writer = bam::io::Writer::new(file.reopen().unwrap());
652        writer.write_header(&header).unwrap();
653        for record in records {
654            writer.write_alignment_record(&header, &record).unwrap();
655        }
656        writer.try_finish().unwrap();
657        file
658    }
659
660    fn raw_bam_file(contents: &str) -> NamedTempFile {
661        let mut reader = sam::io::Reader::new(contents.as_bytes());
662        let header = reader.read_header().unwrap();
663        let records = reader
664            .record_bufs(&header)
665            .collect::<std::io::Result<Vec<_>>>()
666            .unwrap();
667        let file = NamedTempFile::new().unwrap();
668        let mut writer = bam::io::Writer::from(file.reopen().unwrap());
669        writer.write_header(&header).unwrap();
670        for record in records {
671            writer.write_alignment_record(&header, &record).unwrap();
672        }
673        file
674    }
675
676    fn bgzf_sam_file(contents: &str) -> NamedTempFile {
677        let file = NamedTempFile::new().unwrap();
678        let mut writer = bgzf::io::Writer::new(file.reopen().unwrap());
679        writer.write_all(contents.as_bytes()).unwrap();
680        writer.try_finish().unwrap();
681        file
682    }
683
684    #[test]
685    fn merges_sources_and_builds_samples() {
686        let first = sam_file(FIRST);
687        let second = bam_file(SECOND);
688        let inputs = [
689            AlignmentInput::new(7, first.path(), "first"),
690            AlignmentInput::new(9, second.path(), "second"),
691        ];
692        let mut set = AlignmentSet::open(inputs, None, SampleSelection::default()).unwrap();
693
694        assert_eq!(
695            set.reference_sequences(),
696            [ReferenceSequence {
697                name: Box::from(&b"chr1"[..]),
698                length: 20
699            }]
700        );
701        assert_eq!(
702            set.samples()
703                .samples()
704                .iter()
705                .map(AsRef::as_ref)
706                .collect::<Vec<_>>(),
707            ["S1", "S2"]
708        );
709
710        let (source, record) = set.next_record().unwrap().unwrap();
711        assert_eq!(
712            (source, record.name(), record.alignment_start()),
713            (9, b"r2".as_slice(), 1)
714        );
715        assert_eq!(set.samples().sample_index(source, &record), Ok(Some(1)));
716
717        let (source, record) = set.next_record().unwrap().unwrap();
718        assert_eq!(
719            (source, record.name(), record.alignment_start()),
720            (7, b"r1".as_slice(), 2)
721        );
722        assert_eq!(set.samples().sample_index(source, &record), Ok(Some(0)));
723        assert!(set.next_record().unwrap().is_none());
724    }
725
726    #[test]
727    fn rejects_reference_dictionary_mismatch() {
728        let first = sam_file(FIRST);
729        let second = sam_file(&SECOND.replace("LN:20", "LN:21"));
730        let inputs = [
731            AlignmentInput::new(7, first.path(), "first"),
732            AlignmentInput::new(9, second.path(), "second"),
733        ];
734        assert!(matches!(
735            AlignmentSet::open(inputs, None, SampleSelection::default()),
736            Err(CallError::ReferenceDictionaryMismatch(_))
737        ));
738    }
739
740    #[test]
741    fn reads_raw_bam_and_bgzf_sam() {
742        for file in [raw_bam_file(FIRST), bgzf_sam_file(FIRST)] {
743            let mut set = AlignmentSet::open(
744                [AlignmentInput::new(1, file.path(), "first")],
745                None,
746                SampleSelection::default(),
747            )
748            .unwrap();
749            let (_, record) = set.next_record().unwrap().unwrap();
750            assert_eq!(
751                (record.name(), record.alignment_start()),
752                (b"r1".as_slice(), 2)
753            );
754            assert!(set.next_record().unwrap().is_none());
755        }
756    }
757
758    #[test]
759    fn retains_every_record_in_a_cram_container() {
760        let fixtures = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/golden");
761        let reference = fixtures.join("alignment-reference.fa");
762        let mut set = AlignmentSet::open(
763            [AlignmentInput::new(
764                1,
765                fixtures.join("alignment.cram"),
766                "first",
767            )],
768            Some(&reference),
769            SampleSelection::default(),
770        )
771        .unwrap();
772
773        let (_, first) = set.next_record().unwrap().unwrap();
774        let (_, second) = set.next_record().unwrap().unwrap();
775        assert_eq!(
776            (first.name(), first.alignment_start()),
777            (b"r1".as_slice(), 1)
778        );
779        assert_eq!(
780            (second.name(), second.alignment_start()),
781            (b"r2".as_slice(), 2)
782        );
783        assert!(set.next_record().unwrap().is_none());
784    }
785}