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
//! `x-www-form-urlencoded` meets Serde

extern crate dtoa;
extern crate itoa;

pub mod de;
pub mod ser;

#[doc(inline)]
pub use self::de::{from_bytes, from_reader, from_str, Deserializer};
#[doc(inline)]
pub use self::ser::{to_string, Serializer};

#[cfg(test)]
mod tests {
    #[test]
    fn deserialize_bytes() {
        let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];

        assert_eq!(super::from_bytes(b"first=23&last=42"), Ok(result));
    }

    #[test]
    fn deserialize_str() {
        let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];

        assert_eq!(super::from_str("first=23&last=42"), Ok(result));
    }

    #[test]
    fn deserialize_reader() {
        let result = vec![("first".to_owned(), 23), ("last".to_owned(), 42)];

        assert_eq!(super::from_reader(b"first=23&last=42" as &[_]), Ok(result));
    }

    #[test]
    fn deserialize_option() {
        let result = vec![
            ("first".to_owned(), Some(23)),
            ("last".to_owned(), Some(42)),
        ];
        assert_eq!(super::from_str("first=23&last=42"), Ok(result));
    }

    #[test]
    fn deserialize_unit() {
        assert_eq!(super::from_str(""), Ok(()));
        assert_eq!(super::from_str("&"), Ok(()));
        assert_eq!(super::from_str("&&"), Ok(()));
        assert!(super::from_str::<()>("first=23").is_err());
    }

    #[derive(Serialize, Deserialize, Debug, PartialEq, Eq)]
    enum X {
        A,
        B,
        C,
    }

    #[test]
    fn deserialize_unit_enum() {
        let result = vec![
            ("one".to_owned(), X::A),
            ("two".to_owned(), X::B),
            ("three".to_owned(), X::C),
        ];

        assert_eq!(super::from_str("one=A&two=B&three=C"), Ok(result));
    }

    #[test]
    fn serialize_option_map_int() {
        let params = &[("first", Some(23)), ("middle", None), ("last", Some(42))];

        assert_eq!(super::to_string(params), Ok("first=23&last=42".to_owned()));
    }

    #[test]
    fn serialize_option_map_string() {
        let params = &[
            ("first", Some("hello")),
            ("middle", None),
            ("last", Some("world")),
        ];

        assert_eq!(
            super::to_string(params),
            Ok("first=hello&last=world".to_owned())
        );
    }

    #[test]
    fn serialize_option_map_bool() {
        let params = &[("one", Some(true)), ("two", Some(false))];

        assert_eq!(
            super::to_string(params),
            Ok("one=true&two=false".to_owned())
        );
    }

    #[test]
    fn serialize_map_bool() {
        let params = &[("one", true), ("two", false)];

        assert_eq!(
            super::to_string(params),
            Ok("one=true&two=false".to_owned())
        );
    }

    #[test]
    fn serialize_unit_enum() {
        let params = &[("one", X::A), ("two", X::B), ("three", X::C)];
        assert_eq!(
            super::to_string(params),
            Ok("one=A&two=B&three=C".to_owned())
        );
    }
}