reorganize tests and add quassel features

1 files changed, 316 insertions, 10 deletions

diff --git a/src/primitive/variant.rs b/src/primitive/variant.rs
index be2bebe..e9e032e 100644
--- a/src/primitive/variant.rs
+++ b/src/primitive/variant.rs
@@ -10,8 +10,6 @@ use crate::primitive::StringList;
 use crate::{Deserialize, DeserializeUTF8};
 use crate::{Serialize, SerializeUTF8};
 
-extern crate bytes;
-
 use crate::primitive::{BufferInfo, Date, DateTime, Message, Time, VariantList, VariantMap};
 
 /// Variant represents the possible types we can receive
@@ -21,7 +19,7 @@ use crate::primitive::{BufferInfo, Date, DateTime, Message, Time, VariantList, V
 /// BufferInfo and Message are UserTypes
 /// but we represent them as a native Type here.
 ///
-/// StringUTF8 is de-/serialized as a C ByteArray.
+/// ByteArray is de-/serialized as a C ByteArray.
 #[allow(non_camel_case_types, dead_code)]
 #[derive(Clone, Debug, std::cmp::PartialEq)]
 pub enum Variant {
@@ -35,7 +33,6 @@ pub enum Variant {
     VariantMap(VariantMap),
     VariantList(VariantList),
     String(String),
-    StringUTF8(String),
     ByteArray(String),
     StringList(StringList),
     bool(bool),
@@ -73,11 +70,6 @@ impl Serialize for Variant {
                 res.extend(unknown.to_be_bytes().iter());
                 res.extend(v.serialize()?.iter());
             }
-            Variant::StringUTF8(v) => {
-                res.extend(primitive::QBYTEARRAY.to_be_bytes().iter());
-                res.extend(unknown.to_be_bytes().iter());
-                res.extend(v.serialize_utf8()?.iter());
-            }
             Variant::ByteArray(v) => {
                 res.extend(primitive::QBYTEARRAY.to_be_bytes().iter());
                 res.extend(unknown.to_be_bytes().iter());
@@ -199,7 +191,7 @@ impl Deserialize for Variant {
             primitive::QBYTEARRAY => {
                 trace!(target: "primitive::Variant", "Parsing Variant: ByteArray");
                 let (vlen, value) = String::parse_utf8(&b[len..])?;
-                return Ok((len + vlen, Variant::StringUTF8(value.clone())));
+                return Ok((len + vlen, Variant::ByteArray(value.clone())));
             }
             primitive::QSTRINGLIST => {
                 trace!(target: "primitive::Variant", "Parsing Variant: StringList");
@@ -320,3 +312,317 @@ impl Deserialize for Variant {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn signed_serialize() {
+        let i_64 = Variant::i64(847291274197592);
+        let i_32 = Variant::i32(897911521);
+        let i_16 = Variant::i16(8179);
+        let i_8 = Variant::i8(78);
+
+        let i_n_64 = Variant::i64(-847291274197592);
+        let i_n_32 = Variant::i32(-897911521);
+        let i_n_16 = Variant::i16(-8179);
+        let i_n_8 = Variant::i8(-78);
+
+        assert_eq!(
+            i_64.serialize().unwrap(),
+            [0, 0, 0, 129, 0, 0, 3, 2, 155, 95, 107, 122, 88]
+        );
+        assert_eq!(i_32.serialize().unwrap(), [0, 0, 0, 2, 0, 53, 133, 10, 225]);
+        assert_eq!(i_16.serialize().unwrap(), [0, 0, 0, 130, 0, 31, 243]);
+        assert_eq!(i_8.serialize().unwrap(), [0, 0, 0, 131, 0, 78]);
+
+        assert_eq!(
+            i_n_64.serialize().unwrap(),
+            [0, 0, 0, 129, 0, 255, 252, 253, 100, 160, 148, 133, 168]
+        );
+        assert_eq!(
+            i_n_32.serialize().unwrap(),
+            [0, 0, 0, 2, 0, 202, 122, 245, 31]
+        );
+        assert_eq!(i_n_16.serialize().unwrap(), [0, 0, 0, 130, 0, 224, 13]);
+        assert_eq!(i_n_8.serialize().unwrap(), [0, 0, 0, 131, 0, 178]);
+    }
+
+    #[test]
+    fn unsigned_serialize() {
+        let u_64 = Variant::u64(847291274197592);
+        let u_32 = Variant::u32(897911521);
+        let u_16 = Variant::u16(8179);
+        let u_8 = Variant::u8(78);
+
+        assert_eq!(
+            u_64.serialize().unwrap(),
+            [0, 0, 0, 132, 0, 0, 3, 2, 155, 95, 107, 122, 88]
+        );
+        assert_eq!(u_32.serialize().unwrap(), [0, 0, 0, 3, 0, 53, 133, 10, 225]);
+        assert_eq!(u_16.serialize().unwrap(), [0, 0, 0, 133, 0, 31, 243]);
+        assert_eq!(u_8.serialize().unwrap(), [0, 0, 0, 134, 0, 78]);
+    }
+
+    #[test]
+    fn variant_signed_deserialize() {
+        let i_64 = Variant::i64(847291274197592);
+        let i_32 = Variant::i32(897911521);
+        let i_16 = Variant::i16(8179);
+        let i_8 = Variant::i8(78);
+
+        let i_n_64 = Variant::i64(-847291274197592);
+        let i_n_32 = Variant::i32(-897911521);
+        let i_n_16 = Variant::i16(-8179);
+        let i_n_8 = Variant::i8(-78);
+
+        let (_, v_i_64) =
+            Variant::parse(&[0, 0, 0, 129, 0, 0, 3, 2, 155, 95, 107, 122, 88]).unwrap();
+        let (_, v_i_32) = Variant::parse(&[0, 0, 0, 2, 0, 53, 133, 10, 225]).unwrap();
+        let (_, v_i_16) = Variant::parse(&[0, 0, 0, 130, 0, 31, 243]).unwrap();
+        let (_, v_i_8) = Variant::parse(&[0, 0, 0, 131, 0, 78]).unwrap();
+
+        let (_, v_i_n_64) =
+            Variant::parse(&[0, 0, 0, 129, 0, 255, 252, 253, 100, 160, 148, 133, 168]).unwrap();
+        let (_, v_i_n_32) = Variant::parse(&[0, 0, 0, 2, 0, 202, 122, 245, 31]).unwrap();
+        let (_, v_i_n_16) = Variant::parse(&[0, 0, 0, 130, 0, 224, 13]).unwrap();
+        let (_, v_i_n_8) = Variant::parse(&[0, 0, 0, 131, 0, 178]).unwrap();
+
+        assert_eq!(i_64, v_i_64);
+        assert_eq!(i_32, v_i_32);
+        assert_eq!(i_16, v_i_16);
+        assert_eq!(i_8, v_i_8);
+
+        assert_eq!(i_n_64, v_i_n_64);
+        assert_eq!(i_n_32, v_i_n_32);
+        assert_eq!(i_n_16, v_i_n_16);
+        assert_eq!(i_n_8, v_i_n_8);
+    }
+
+    #[test]
+    fn unsigned_deserialize() {
+        let u_64 = Variant::u64(847291274197592);
+        let u_32 = Variant::u32(897911521);
+        let u_16 = Variant::u16(8179);
+        let u_8 = Variant::u8(78);
+
+        let (_, v_u_64) =
+            Variant::parse(&[0, 0, 0, 132, 0, 0, 3, 2, 155, 95, 107, 122, 88]).unwrap();
+        let (_, v_u_32) = Variant::parse(&[0, 0, 0, 3, 0, 53, 133, 10, 225]).unwrap();
+        let (_, v_u_16) = Variant::parse(&[0, 0, 0, 133, 0, 31, 243]).unwrap();
+        let (_, v_u_8) = Variant::parse(&[0, 0, 0, 134, 0, 78]).unwrap();
+
+        assert_eq!(u_64, v_u_64);
+        assert_eq!(u_32, v_u_32);
+        assert_eq!(u_16, v_u_16);
+        assert_eq!(u_8, v_u_8);
+    }
+
+    #[test]
+    pub fn bool_serialize() {
+        let test_variant_true = Variant::bool(true);
+        let test_variant_false = Variant::bool(false);
+        assert_eq!(test_variant_true.serialize().unwrap(), [0, 0, 0, 1, 0, 1]);
+        assert_eq!(test_variant_false.serialize().unwrap(), [0, 0, 0, 1, 0, 0]);
+    }
+
+    #[test]
+    pub fn bool_deserialize() {
+        let test_bytes: &[u8] = &[0, 0, 0, 1, 0, 1, 0, 0, 0, 1];
+        let (len, res) = Variant::parse(test_bytes).unwrap();
+        assert_eq!(len, 6);
+        assert_eq!(res, Variant::bool(true));
+    }
+
+    #[test]
+    pub fn variantlist_serialize() {
+        let mut test_variantlist = VariantList::new();
+        test_variantlist.push(Variant::bool(true));
+        assert_eq!(
+            test_variantlist.serialize().unwrap(),
+            [0, 0, 0, 1, 0, 0, 0, 1, 0, 1]
+        );
+    }
+
+    #[test]
+    pub fn variantlist_deserialize() {
+        let test_bytes: &[u8] = &[0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1];
+        let (len, res) = VariantList::parse(test_bytes).unwrap();
+        let mut test_variantlist = VariantList::new();
+        test_variantlist.push(Variant::bool(true));
+        assert_eq!(len, 10);
+        assert_eq!(res, test_variantlist);
+    }
+
+    #[test]
+    pub fn variantmap_serialize() {
+        let mut test_variantmap = VariantMap::new();
+        test_variantmap.insert("Configured".to_string(), Variant::bool(true));
+        let bytes = [
+            0, 0, 0, 1, 0, 0, 0, 20, 0, 67, 0, 111, 0, 110, 0, 102, 0, 105, 0, 103, 0, 117, 0, 114,
+            0, 101, 0, 100, 0, 0, 0, 1, 0, 1,
+        ]
+        .to_vec();
+        assert_eq!(test_variantmap.serialize().unwrap(), bytes);
+    }
+
+    #[test]
+    pub fn variantmap_deserialize() {
+        let test_bytes: &[u8] = &[
+            0, 0, 0, 1, 0, 0, 0, 20, 0, 67, 0, 111, 0, 110, 0, 102, 0, 105, 0, 103, 0, 117, 0, 114,
+            0, 101, 0, 100, 0, 0, 0, 1, 0, 1,
+        ];
+        let (len, res) = VariantMap::parse(test_bytes).unwrap();
+        let mut test_variantmap = VariantMap::new();
+        test_variantmap.insert("Configured".to_string(), Variant::bool(true));
+        assert_eq!(len, 34);
+        assert_eq!(res, test_variantmap);
+    }
+
+    #[test]
+    pub fn buffer_info_serialize() {
+        let test_buffer_info = BufferInfo {
+            id: 0,
+            network_id: 0,
+            buffer_type: primitive::BufferType::Status,
+            name: "test".to_string(),
+        };
+
+        let bytes = vec![
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x4, 0x74, 0x65, 0x73, 0x74,
+        ];
+        assert_eq!(test_buffer_info.serialize().unwrap(), bytes);
+    }
+
+    #[test]
+    pub fn buffer_info_deserialize() {
+        let test_buffer_info = BufferInfo {
+            id: 0,
+            network_id: 0,
+            buffer_type: primitive::BufferType::Status,
+            name: "test".to_string(),
+        };
+
+        let bytes = vec![
+            0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+            0x5, 0x74, 0x65, 0x73, 0x74, 0x0,
+        ];
+        let (len, res) = BufferInfo::parse(&bytes).unwrap();
+
+        assert_eq!(len, 23);
+        assert_eq!(res, test_buffer_info);
+    }
+
+    #[test]
+    fn strings_serialize() {
+        let test_string = "This is a Test!1!!".to_string();
+        let test_string_list = vec!["test1".to_string(), "test 2".to_string()];
+
+        assert_eq!(
+            Variant::String(test_string.clone()).serialize().unwrap(),
+            [
+                0, 0, 0, 10, 0, 0, 0, 0, 36, 0, 0x54, 0, 0x68, 0, 0x69, 0, 0x73, 0, 0x20, 0, 0x69,
+                0, 0x73, 0, 0x20, 0, 0x61, 0, 0x20, 0, 0x54, 0, 0x65, 0, 0x73, 0, 0x74, 0, 0x21, 0,
+                0x31, 0, 0x21, 0, 0x21
+            ]
+        );
+        assert_eq!(
+            Variant::ByteArray(test_string.clone()).serialize().unwrap(),
+            [
+                0, 0, 0, 12, 0, 0, 0, 0, 18, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61,
+                0x20, 0x54, 0x65, 0x73, 0x74, 0x21, 0x31, 0x21, 0x21
+            ]
+        );
+        assert_eq!(
+            Variant::StringList(test_string_list).serialize().unwrap(),
+            [
+                0, 0, 0, 11, 0, 0, 0, 0, 2, 0, 0, 0, 10, 0, 0x74, 0, 0x65, 0, 0x73, 0, 0x74, 0,
+                0x31, 0, 0, 0, 12, 0, 0x74, 0, 0x65, 0, 0x73, 0, 0x74, 0, 0x20, 0, 0x32
+            ]
+        );
+    }
+
+    #[test]
+    fn strings_deserialize() {
+        let test_string = "This is a Test!1!!".to_string();
+        let test_string_list = vec!["test1".to_string(), "test 2".to_string()];
+
+        let test_string_src = vec![
+            0, 0, 0, 10, 0, 0, 0, 0, 36, 0, 0x54, 0, 0x68, 0, 0x69, 0, 0x73, 0, 0x20, 0, 0x69, 0,
+            0x73, 0, 0x20, 0, 0x61, 0, 0x20, 0, 0x54, 0, 0x65, 0, 0x73, 0, 0x74, 0, 0x21, 0, 0x31,
+            0, 0x21, 0, 0x21,
+        ];
+
+        let test_string_src_utf8 = vec![
+            0, 0, 0, 12, 0, 0, 0, 0, 18, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61,
+            0x20, 0x54, 0x65, 0x73, 0x74, 0x21, 0x31, 0x21, 0x21, 0,
+        ];
+
+        let test_string_list_src = vec![
+            0, 0, 0, 11, 0, 0, 0, 0, 2, 0, 0, 0, 10, 0, 0x74, 0, 0x65, 0, 0x73, 0, 0x74, 0, 0x31,
+            0, 0, 0, 12, 0, 0x74, 0, 0x65, 0, 0x73, 0, 0x74, 0, 0x20, 0, 0x32,
+        ];
+
+        assert_eq!(
+            (45, Variant::String(test_string.clone())),
+            Variant::parse(&test_string_src).unwrap()
+        );
+        assert_eq!(
+            (27, Variant::ByteArray(test_string.clone())),
+            Variant::parse(&test_string_src_utf8).unwrap()
+        );
+        assert_eq!(
+            (39, Variant::StringList(test_string_list)),
+            Variant::parse(&test_string_list_src).unwrap()
+        );
+    }
+
+    #[test]
+    fn datetime_serialize() {
+        let datetime =
+            Variant::DateTime(DateTime::parse("2020-02-19 13:00 +0200", "%Y-%m-%d %R %z").unwrap());
+        let date = Variant::Date(Date::parse("2020-02-19", "%Y-%m-%d").unwrap());
+        let time = Variant::Time(Time::parse("13:00", "%R").unwrap());
+
+        assert_eq!(
+            datetime.serialize().unwrap(),
+            [0, 0, 0, 0x10, 0, 0, 37, 133, 19, 2, 202, 28, 128, 3, 0, 0, 28, 32]
+        );
+
+        assert_eq!(
+            date.serialize().unwrap(),
+            [0, 0, 0, 0x0e, 0, 0, 37, 133, 19]
+        );
+
+        assert_eq!(
+            time.serialize().unwrap(),
+            [0, 0, 0, 0x0f, 0, 2, 202, 28, 128]
+        );
+    }
+
+    #[test]
+    fn datetime_deserialize() {
+        let datetime =
+            Variant::DateTime(DateTime::parse("2020-02-19 13:00 +0200", "%Y-%m-%d %R %z").unwrap());
+        let date = Variant::Date(Date::parse("2020-02-19", "%Y-%m-%d").unwrap());
+        let time = Variant::Time(Time::parse("13:00", "%R").unwrap());
+
+        assert_eq!(
+            (18, datetime),
+            Variant::parse(&[0, 0, 0, 0x10, 0, 0, 37, 133, 19, 2, 202, 28, 128, 3, 0, 0, 28, 32])
+                .unwrap()
+        );
+
+        assert_eq!(
+            (9, date),
+            Variant::parse(&[0, 0, 0, 0x0e, 0, 0, 37, 133, 19]).unwrap()
+        );
+
+        assert_eq!(
+            (9, time),
+            Variant::parse(&[0, 0, 0, 0x0f, 0, 2, 202, 28, 128]).unwrap()
+        );
+    }
+}