qubit-codec-text 0.1.0

Buffer-oriented text encoding and decoding utilities for Rust
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
119
120
121
122
123
124
125
126
127
128

use qubit_codec_text::{
    Charset,
    CharsetDecodeError,
    CharsetDecodeErrorKind,
};

#[test]
fn test_charset_decode_error_exposes_context() {
    let kind = CharsetDecodeErrorKind::MalformedSequence { value: None };
    let error = CharsetDecodeError::new(Charset::UTF_8, kind, 7);

    assert_eq!(Charset::UTF_8, error.charset());
    assert_eq!(
        CharsetDecodeErrorKind::MalformedSequence { value: None },
        error.kind()
    );
    assert_eq!(7, error.index());
    assert_eq!(None, error.value());
    assert_eq!(10, error.offset_by(3).index());
    assert_eq!(
        "UTF-8 decoding error at index 7: The encoded text sequence is malformed.",
        error.to_string(),
    );

    let kind = CharsetDecodeErrorKind::IncompleteSequence {
        required: 7,
        available: 0,
    };
    let incomplete = CharsetDecodeError::new(Charset::UTF_16, kind, 3);
    assert_eq!(Charset::UTF_16, incomplete.charset());
    assert!(matches!(
        incomplete.kind(),
        CharsetDecodeErrorKind::IncompleteSequence { .. },
    ));
    assert_eq!(3, incomplete.index());
    assert_eq!(
        7,
        incomplete
            .required()
            .expect("required payload is set for incomplete sequence"),
    );
    assert_eq!(
        0,
        incomplete
            .available()
            .expect("available payload is set for incomplete sequence"),
    );
    assert_eq!(
        "UTF-16 decoding error at index 3: The encoded text sequence is incomplete (required 7 units, available 0 units).",
        incomplete.to_string(),
    );

    let kind = CharsetDecodeErrorKind::InvalidCodePoint { value: 0x110000 };
    let invalid = CharsetDecodeError::new(Charset::UTF_32, kind, 5);
    assert_eq!(Charset::UTF_32, invalid.charset());
    assert!(matches!(
        invalid.kind(),
        CharsetDecodeErrorKind::InvalidCodePoint { value: 0x110000 },
    ));
    assert_eq!(5, invalid.index());
    assert_eq!(Some(0x110000), invalid.value());
    assert_eq!(
        "UTF-32 decoding error at index 5 for value 0x110000: The decoded code point 0x110000 is not a valid Unicode scalar value.",
        invalid.to_string(),
    );

    let kind = CharsetDecodeErrorKind::InvalidInputIndex { input_len: 2 };
    let invalid_index = CharsetDecodeError::new(Charset::UTF_8, kind, 3);
    assert_eq!(Some(2), invalid_index.input_len());
    assert_eq!(
        "UTF-8 decoding error at index 3: The input unit index is outside the input buffer.",
        invalid_index.to_string(),
    );

    let kind = CharsetDecodeErrorKind::InvalidOutputIndex { output_len: 2 };
    let invalid_output = CharsetDecodeError::new(Charset::UTF_8, kind, 4);
    assert_eq!(Some(2), invalid_output.output_len());
}

#[test]
fn test_charset_decode_error_offset_saturates_on_overflow() {
    let error = CharsetDecodeError::new(
        Charset::UTF_8,
        CharsetDecodeErrorKind::MalformedSequence { value: None },
        usize::MAX - 1,
    );

    assert_eq!(usize::MAX, error.offset_by(2).index());
}

#[test]
fn test_charset_decode_error_exposes_consumption_and_incomplete_details() {
    let malformed = CharsetDecodeError::new(
        Charset::UTF_8,
        CharsetDecodeErrorKind::MalformedSequence { value: Some(0x80) },
        4,
    )
    .with_consumed(2);
    assert_eq!(Some(2), malformed.consumed());
    assert_eq!(Some(0x80), malformed.value());

    let invalid_code_point = CharsetDecodeError::new(
        Charset::UTF_32,
        CharsetDecodeErrorKind::InvalidCodePoint { value: 0x110000 },
        1,
    );
    assert_eq!(Some(1), invalid_code_point.consumed());

    let incomplete = CharsetDecodeError::new(
        Charset::UTF_16,
        CharsetDecodeErrorKind::IncompleteSequence {
            required: 4,
            available: 1,
        },
        0,
    );
    assert_eq!(None, incomplete.consumed());
    assert_eq!(Some(4), incomplete.required());
    assert_eq!(Some(1), incomplete.available());

    let invalid_index = CharsetDecodeError::new(
        Charset::UTF_8,
        CharsetDecodeErrorKind::InvalidInputIndex { input_len: 1 },
        3,
    );
    assert_eq!(None, invalid_index.consumed());
    assert_eq!(Some(1), invalid_index.input_len());
}