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

use qubit_codec_text::{
    Charset,
    CharsetEncodeError,
    CharsetEncodeErrorKind,
};

#[test]
fn test_charset_encode_error_exposes_context() {
    const GBK: Charset = Charset::new("gbk", "GBK", &["cp936"]);

    let kind = CharsetEncodeErrorKind::BufferTooSmall {
        required: 4,
        available: 1,
    };
    let error = CharsetEncodeError::new(Charset::UTF_16, kind, 2);

    assert_eq!(Charset::UTF_16, error.charset());
    assert!(matches!(
        error.kind(),
        CharsetEncodeErrorKind::BufferTooSmall { .. },
    ));
    assert_eq!(2, error.index());
    assert_eq!(None, error.value());
    assert_eq!(7, error.offset_by(5).index());
    assert_eq!(
        "UTF-16 encoding error at index 2: The output buffer is too small (required 4 units, available 1 units).",
        error.to_string(),
    );

    let kind = CharsetEncodeErrorKind::InvalidCodePoint { value: 0x110000 };
    let invalid = CharsetEncodeError::new(Charset::UTF_8, kind, 0);
    assert_eq!(Charset::UTF_8, invalid.charset());
    assert!(matches!(
        invalid.kind(),
        CharsetEncodeErrorKind::InvalidCodePoint { value: 0x110000 },
    ));
    assert_eq!(0, invalid.index());
    assert_eq!(Some(0x110000), invalid.value());
    assert_eq!(
        "UTF-8 encoding error at index 0 for value 0x110000: The code point is not a valid Unicode scalar value.",
        invalid.to_string(),
    );

    let kind = CharsetEncodeErrorKind::UnmappableCharacter {
        value: '中' as u32,
    };
    let unmappable = CharsetEncodeError::new(GBK, kind, 4);
    assert_eq!(GBK, unmappable.charset());
    assert_eq!(
        CharsetEncodeErrorKind::UnmappableCharacter {
            value: '中' as u32
        },
        unmappable.kind()
    );
    assert_eq!(4, unmappable.index());
    assert_eq!(Some('中' as u32), unmappable.value());

    let kind = CharsetEncodeErrorKind::InvalidInputIndex { input_len: 0 };
    let invalid_index = CharsetEncodeError::new(Charset::UTF_8, kind, 8);
    assert_eq!(Charset::UTF_8, invalid_index.charset());
    assert_eq!(
        CharsetEncodeErrorKind::InvalidInputIndex { input_len: 0 },
        invalid_index.kind()
    );
    assert_eq!(Some(0), invalid_index.kind().input_len());
    assert_eq!(8, invalid_index.index());
    assert_eq!(None, invalid_index.value());

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

#[test]
fn test_charset_encode_error_offset_saturates_on_overflow() {
    let kind = CharsetEncodeErrorKind::BufferTooSmall {
        required: 1,
        available: 0,
    };
    let error = CharsetEncodeError::new(Charset::UTF_8, kind, usize::MAX - 1);

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