qubit-text-codec 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

use qubit_text_codec::CharsetEncodeErrorKind;

#[test]
fn test_charset_encode_error_kind_displays_messages() {
    assert_eq!(
        "The code point is not a valid Unicode scalar value.",
        CharsetEncodeErrorKind::InvalidCodePoint { value: 0x110000 }.to_string(),
    );
    assert_eq!(
        "The character cannot be represented by the target encoding.",
        CharsetEncodeErrorKind::UnmappableCharacter { value: 0x110000 }.to_string(),
    );
    assert_eq!(
        "The input character index is outside the input buffer.",
        CharsetEncodeErrorKind::InvalidInputIndex { input_len: 0 }.to_string(),
    );
    assert_eq!(
        "The output buffer is too small (required 4 units, available 1 units).",
        CharsetEncodeErrorKind::BufferTooSmall {
            required: 4,
            available: 1,
        }
        .to_string(),
    );

    let invalid = CharsetEncodeErrorKind::InvalidCodePoint { value: 0x110000 };
    assert_eq!(None, invalid.required());
    assert_eq!(None, invalid.available());
    assert_eq!(Some(0x110000), invalid.value());

    let unmappable = CharsetEncodeErrorKind::UnmappableCharacter { value: 0x110000 };
    assert_eq!(None, unmappable.required());
    assert_eq!(None, unmappable.available());
    assert_eq!(Some(0x110000), unmappable.value());

    assert_eq!(
        None,
        CharsetEncodeErrorKind::InvalidInputIndex { input_len: 0 }.required()
    );
    assert_eq!(
        None,
        CharsetEncodeErrorKind::InvalidInputIndex { input_len: 0 }.available()
    );
    assert_eq!(None, CharsetEncodeErrorKind::InvalidInputIndex { input_len: 0 }.value());

    let buffer = CharsetEncodeErrorKind::BufferTooSmall {
        required: 4,
        available: 1,
    };
    assert_eq!(Some(4), buffer.required());
    assert_eq!(Some(1), buffer.available());
    assert_eq!(None, buffer.value());
}