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 != ¤t_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}