nafcodec 0.3.1

Rust coder/decoder for Nucleotide Archive Format (NAF) files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use nafcodec::Decoder;
use nafcodec::DecoderBuilder;
use nafcodec::Flag;
use nafcodec::Header;
use nafcodec::SequenceType;

const ARCHIVE: &[u8] = include_bytes!("../../../data/phix.naf");

fn check_header_flags(header: &Header) {
    assert!(header.flags().test(Flag::Quality));
    assert!(header.flags().test(Flag::Sequence));
    assert!(header.flags().test(Flag::Id));
    assert!(header.flags().test(Flag::Comment));
}

#[test]
fn decode_header() {
    let c = std::io::Cursor::new(ARCHIVE);
    let decoder = Decoder::new(c).unwrap();

    assert_eq!(decoder.header().name_separator(), ' ');
    assert_eq!(decoder.header().number_of_sequences(), 42);
    assert_eq!(decoder.header().sequence_type(), SequenceType::Dna);
    assert!(decoder.header().flags().test(Flag::Quality));
    assert!(decoder.header().flags().test(Flag::Sequence));
    assert!(decoder.header().flags().test(Flag::Id));
    assert!(decoder.header().flags().test(Flag::Comment));
}

#[test]
fn decode() {
    let c = std::io::Cursor::new(ARCHIVE);
    let mut decoder = Decoder::new(c).unwrap();
    check_header_flags(decoder.header());

    let r1 = decoder.next().unwrap().unwrap();
    assert_eq!(r1.id.unwrap(), "SRR1377138.1");
    assert_eq!(
        r1.comment.unwrap(),
        "a comment that should not be included in the SAM output"
    );
    let seq = r1.sequence.unwrap();
    assert!(seq.starts_with("NGCTCTTAAACCTGCTATTGAGGCTTGTGGCATTTC"));
    let qual = r1.quality.unwrap();
    assert!(qual.starts_with("#8CCCGGGGGGGGGGGGGGGGGGGGGGGGGG"));

    let r2 = decoder.next().unwrap().unwrap();
    assert_eq!(r2.id.unwrap(), "SRR1377138.2");
    assert_eq!(r2.comment.unwrap(), "some lowercase nucleotides");

    let records = decoder.collect::<Result<Vec<_>, _>>().unwrap();
    assert_eq!(records.len(), 40);
}

#[test]
fn decode_no_id() {
    let mut decoder = DecoderBuilder::new().id(false).with_bytes(ARCHIVE).unwrap();
    check_header_flags(decoder.header());

    let r1 = decoder.next().unwrap().unwrap();
    assert!(r1.id.is_none());
    let r2 = decoder.next().unwrap().unwrap();
    assert!(r2.id.is_none());

    let records = decoder.collect::<Result<Vec<_>, _>>().unwrap();
    assert_eq!(records.len(), 40);
}

#[test]
fn decode_no_seq() {
    let mut decoder = DecoderBuilder::new()
        .sequence(false)
        .with_bytes(ARCHIVE)
        .unwrap();
    check_header_flags(decoder.header());

    let r1 = decoder.next().unwrap().unwrap();
    assert!(r1.sequence.is_none());
    let r2 = decoder.next().unwrap().unwrap();
    assert!(r2.sequence.is_none());

    let records = decoder.collect::<Result<Vec<_>, _>>().unwrap();
    assert_eq!(records.len(), 40);
}

#[test]
fn decode_no_comment() {
    let mut decoder = DecoderBuilder::new()
        .comment(false)
        .with_bytes(ARCHIVE)
        .unwrap();
    check_header_flags(decoder.header());

    let r1 = decoder.next().unwrap().unwrap();
    assert!(r1.comment.is_none());
    let r2 = decoder.next().unwrap().unwrap();
    assert!(r2.comment.is_none());

    let records = decoder.collect::<Result<Vec<_>, _>>().unwrap();
    assert_eq!(records.len(), 40);
}

#[test]
fn decode_no_quality() {
    let mut decoder = DecoderBuilder::new()
        .quality(false)
        .with_bytes(ARCHIVE)
        .unwrap();
    check_header_flags(decoder.header());

    let r1 = decoder.next().unwrap().unwrap();
    assert!(r1.quality.is_none());
    let r2 = decoder.next().unwrap().unwrap();
    assert!(r2.quality.is_none());

    let records = decoder.collect::<Result<Vec<_>, _>>().unwrap();
    assert_eq!(records.len(), 40);
}