qubit-codec-misc 0.1.0

Miscellaneous byte and text format codecs for Rust applications
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

// =============================================================================
//    Copyright (c) 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================
//! Tests for lightweight encoder and decoder traits.

use qubit_codec::{
    BufferedDecodeEngine,
    BufferedDecoder,
    BufferedEncodeEngine,
    BufferedEncoder,
    CodecBufferedDecoder,
    CodecBufferedEncoder,
    CodecDecodeError,
    CodecEncodeError,
    CodecValueEncoder,
    EncodePlan,
};
use qubit_codec_misc::{
    FormUrlencodedCodec,
    HexCodec,
    PercentCodec,
    ValueDecoder,
    ValueEncoder,
};

#[test]
fn test_codec_types_can_be_used_through_traits() {
    let codec = HexCodec::new();
    let encoded = ValueEncoder::<[u8]>::encode(&codec, b"abc")
        .expect("hex encode should succeed");
    let decoded = ValueDecoder::<str>::decode(&codec, &encoded)
        .expect("hex decode should succeed");

    assert_eq!("616263", encoded);
    assert_eq!(b"abc".to_vec(), decoded);
}

#[test]
fn test_core_codec_adapter_types_can_wrap_misc_codecs() {
    fn assert_codec_value_encoder<
        T: ValueEncoder<
                u8,
                Output = Vec<u8>,
                Error = qubit_codec_misc::MiscCodecError,
            >,
    >() {
    }
    fn assert_codec_buffered_decoder<T: BufferedDecoder<u8, u8>>() {}
    fn assert_codec_buffered_encoder<T: BufferedEncoder<u8, u8>>() {}
    fn assert_buffered_decode_engine<T>() {}
    fn assert_buffered_encode_engine<T>() {}

    assert_codec_value_encoder::<CodecValueEncoder<HexCodec>>();
    assert_codec_buffered_decoder::<CodecBufferedDecoder<HexCodec>>();
    assert_codec_buffered_encoder::<CodecBufferedEncoder<HexCodec>>();
    assert_buffered_decode_engine::<BufferedDecodeEngine<HexCodec, ()>>();
    assert_buffered_encode_engine::<BufferedEncodeEngine<HexCodec, ()>>();

    let plan = EncodePlan::new(1, ());
    assert_eq!(1, plan.max_output_units);
    let encode_error =
        CodecEncodeError::<core::convert::Infallible>::invalid_input_index(
            2, 1,
        );
    assert!(matches!(
        encode_error,
        CodecEncodeError::InvalidInputIndex { .. }
    ));
    let decode_error =
        CodecDecodeError::<core::convert::Infallible>::invalid_input_index(
            2, 1,
        );
    assert!(matches!(
        decode_error,
        CodecDecodeError::InvalidInputIndex { .. }
    ));
}

#[test]
fn test_value_traits_accept_text_codecs() {
    fn roundtrip<C>(codec: &C, text: &str) -> String
    where
        C: ValueEncoder<
                str,
                Output = String,
                Error = qubit_codec_misc::MiscCodecError,
            > + ValueDecoder<
                str,
                Output = String,
                Error = qubit_codec_misc::MiscCodecError,
            >,
    {
        let encoded = ValueEncoder::<str>::encode(codec, text)
            .expect("text should encode");
        ValueDecoder::<str>::decode(codec, &encoded)
            .expect("text should decode")
    }

    assert_eq!("a b", roundtrip(&PercentCodec::new(), "a b"));
    assert_eq!("a b", roundtrip(&FormUrlencodedCodec::new(), "a b"));
}