extern crate gob;
extern crate serde;
extern crate serde_bytes;
#[macro_use]
extern crate serde_derive;
extern crate serde_schema;
#[macro_use]
extern crate serde_schema_derive;

use std::collections::BTreeMap;

use gob::StreamSerializer;
use serde_bytes::Bytes;

#[test]
fn bool_true() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&true).unwrap();
    }
    assert_eq!(buffer, &[3, 2, 0, 1]);
}

#[test]
fn bool_false() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&false).unwrap();
    }
    assert_eq!(buffer, &[3, 2, 0, 0]);
}

#[test]
fn u8_zero() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&0u8).unwrap();
    }
    assert_eq!(buffer, &[3, 6, 0, 0]);
}

#[test]
fn u16_zero() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&0u16).unwrap();
    }
    assert_eq!(buffer, &[3, 6, 0, 0]);
}

#[test]
fn u32_zero() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&0u32).unwrap();
    }
    assert_eq!(buffer, &[3, 6, 0, 0]);
}

#[test]
fn u64_zero() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&0u64).unwrap();
    }
    assert_eq!(buffer, &[3, 6, 0, 0]);
}

#[test]
fn u64_small() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&42u64).unwrap();
    }
    assert_eq!(buffer, &[3, 6, 0, 42]);
}

#[test]
fn u64_big() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&1234u64).unwrap();
    }
    assert_eq!(buffer, &[5, 6, 0, 254, 4, 210]);
}

#[test]
fn u64_max() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&::std::u64::MAX).unwrap();
    }
    assert_eq!(
        buffer,
        &[11, 6, 0, 248, 255, 255, 255, 255, 255, 255, 255, 255]
    );
}

#[test]
fn i8_zero() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&0i8).unwrap();
    }
    assert_eq!(buffer, &[3, 4, 0, 0]);
}

#[test]
fn i16_zero() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&0i16).unwrap();
    }
    assert_eq!(buffer, &[3, 4, 0, 0]);
}

#[test]
fn i32_zero() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&0i32).unwrap();
    }
    assert_eq!(buffer, &[3, 4, 0, 0]);
}

#[test]
fn i64_zero() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&0i64).unwrap();
    }
    assert_eq!(buffer, &[3, 4, 0, 0]);
}

#[test]
fn i64_small_pos() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&42i64).unwrap();
    }
    assert_eq!(buffer, &[3, 4, 0, 84]);
}

#[test]
fn i64_small_neg() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&-42i64).unwrap();
    }
    assert_eq!(buffer, &[3, 4, 0, 83]);
}

#[test]
fn i64_big_pos() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&1234i64).unwrap();
    }
    assert_eq!(buffer, &[5, 4, 0, 254, 9, 164]);
}

#[test]
fn i64_big_neg() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&-1234i64).unwrap();
    }
    assert_eq!(buffer, &[5, 4, 0, 254, 9, 163]);
}

#[test]
fn i64_min() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&::std::i64::MIN).unwrap();
    }
    assert_eq!(
        buffer,
        &[11, 4, 0, 248, 255, 255, 255, 255, 255, 255, 255, 255]
    );
}

#[test]
fn i64_max() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&::std::i64::MAX).unwrap();
    }
    assert_eq!(
        buffer,
        &[11, 4, 0, 248, 255, 255, 255, 255, 255, 255, 255, 254]
    );
}

#[test]
fn f32_zero() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&0f32).unwrap();
    }
    assert_eq!(buffer, &[3, 8, 0, 0]);
}

#[test]
fn f64_zero() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&0f64).unwrap();
    }
    assert_eq!(buffer, &[3, 8, 0, 0]);
}

#[test]
fn f64_pos() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&42f64).unwrap();
    }
    assert_eq!(buffer, &[5, 8, 0, 254, 69, 64]);
}

#[test]
fn f64_neg() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&-42f64).unwrap();
    }
    assert_eq!(buffer, &[5, 8, 0, 254, 69, 192]);
}

#[test]
fn char_ascii() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&'f').unwrap();
    }
    assert_eq!(buffer, &[4, 4, 0, 255, 204]);
}

#[test]
fn char_unicode() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&'語').unwrap();
    }
    assert_eq!(buffer, &[6, 4, 0, 253, 1, 21, 60]);
}

#[test]
fn bytes_empty() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&Bytes::new(&[])).unwrap();
    }
    assert_eq!(buffer, &[3, 10, 0, 0]);
}

#[test]
fn bytes_non_empty() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&Bytes::new(&[1, 2, 3, 4])).unwrap();
    }
    assert_eq!(buffer, &[7, 10, 0, 4, 1, 2, 3, 4]);
}

#[test]
fn str_empty() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&"").unwrap();
    }
    assert_eq!(buffer, &[3, 12, 0, 0]);
}

#[test]
fn str_non_empty() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&"foo").unwrap();
    }
    assert_eq!(buffer, &[6, 12, 0, 3, 102, 111, 111]);
}

#[test]
fn vec_of_bool_to_empty_slice() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&Vec::<bool>::new()).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/slice_of_bool_empty.gob")
    );
}

#[test]
fn vec_of_bool_to_non_empty_slice() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&vec![true, false]).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/slice_of_bool_non_empty.gob")
    );
}

#[test]
fn vec_of_bool_to_empty_array() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize::<[bool; 0]>(&[]).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/array_of_bool_empty.gob")
    );
}

#[test]
fn vec_of_bool_to_non_empty_array() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&[true, false]).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/array_of_bool_non_empty.gob")
    );
}

#[test]
fn vec_of_bool_to_empty_slice_twice() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&Vec::<bool>::new()).unwrap();
        stream.serialize(&Vec::<bool>::new()).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/slice_of_bool_empty_twice.gob")
    );
}

#[test]
fn vec_of_bool_from_non_empty_slice_twice() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&vec![true, false]).unwrap();
        stream.serialize(&vec![false, true]).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/slice_of_bool_non_empty_twice.gob")
    );
}

#[test]
fn map_empty() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&<BTreeMap<String, bool>>::new()).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/map_empty.gob").as_ref()
    );
}

#[test]
fn map_non_empty() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        let mut map = BTreeMap::new();
        map.insert("foo", true);
        map.insert("bar", false);
        stream.serialize(&map).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/map_non_empty.gob").as_ref()
    );
}

#[derive(Serialize, SchemaSerialize)]
struct Point {
    #[serde(rename = "X")]
    x: i64,
    #[serde(rename = "Y")]
    y: i64,
}

#[test]
fn point_struct() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&Point { x: 22, y: 33 }).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/point_struct.gob").as_ref()
    );
}

#[test]
fn point_struct_skip_x() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&Point { x: 0, y: 42 }).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/point_struct_skip_x.gob").as_ref()
    );
}

#[derive(Serialize, SchemaSerialize)]
struct BoolStruct {
    #[serde(rename = "V")]
    v: bool,
}

#[test]
fn bool_struct() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&BoolStruct { v: true }).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/bool_struct.gob").as_ref()
    );
}

#[test]
fn enum_with_newtype_variants_and_external_tags() {
    #[derive(Serialize, SchemaSerialize)]
    enum Enum {
        #[serde(rename = "Var1")]
        #[allow(unused)]
        V1(bool),
        #[serde(rename = "Var2")]
        V2(i64),
        #[serde(rename = "Var3")]
        #[allow(unused)]
        V3(String),
    }

    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&Enum::V2(42)).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/enum_with_newtype_variants.gob").as_ref()
    );
}

#[test]
fn enum_with_struct_variants_and_external_tags() {
    #[derive(Serialize, SchemaSerialize)]
    enum Enum {
        #[allow(unused)]
        V1 {
            #[serde(rename = "Foo")]
            foo: bool,
        },
        V2 {
            #[serde(rename = "Bar")]
            bar: i64,
            #[serde(rename = "Baz")]
            baz: u64,
        },
        #[allow(unused)]
        V3 {
            #[serde(rename = "Quux")]
            quux: String,
        },
    }

    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&Enum::V2 { bar: 42, baz: 1234 }).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/enum_with_struct_variants.gob").as_ref()
    );
}

#[test]
fn option_none_to_empty_values() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize::<Option<bool>>(&None).unwrap();
        stream.serialize::<Option<u64>>(&None).unwrap();
        stream.serialize::<Option<i64>>(&None).unwrap();
        stream.serialize::<Option<f64>>(&None).unwrap();
        stream.serialize::<Option<String>>(&None).unwrap();
        stream.serialize::<Option<Bytes>>(&None).unwrap();
        stream.serialize::<Option<Vec<bool>>>(&None).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/empty_values.gob").as_ref()
    );
}

#[test]
fn option_some_to_non_empty_values() {
    let mut buffer = Vec::new();
    {
        let mut stream = StreamSerializer::new_with_write(&mut buffer);
        stream.serialize(&Some(true)).unwrap();
        stream.serialize(&Some(42u64)).unwrap();
        stream.serialize(&Some(42i64)).unwrap();
        stream.serialize(&Some(42f64)).unwrap();
        stream.serialize(&Some("foo")).unwrap();
        stream.serialize(&Some(Bytes::new(&[0x1, 0x2]))).unwrap();
        stream.serialize(&Some(vec![true, false])).unwrap();
    }
    assert_eq!(
        buffer,
        include_bytes!("reference/output/non_empty_values.gob").as_ref()
    );
}