doge 0.1.0

use serde_json;
use std;

use de;
use ser;

#[test]
fn test_ser_basic_string_struct() {
    #[derive(Serialize)]
    struct Test {
        foo: &'static str,
        doge: &'static str,
    }

    let test = Test {
        foo: "bar",
        doge: "shibe",
    };

    let expected = r#"such "foo" is "bar","doge" is "shibe" wow"#;
    assert_eq!(ser::to_string(&test).unwrap(), expected);
}

#[test]
fn test_ser_nested_struct() {
    #[derive(Serialize)]
    struct Inner {
        shiba: &'static str,
        doge: bool,
    }
    #[derive(Serialize)]
    struct Test {
        foo: Inner,
    }

    let test = Test {
        foo: Inner {
            shiba: "inu",
            doge: true,
        },
    };

    let expected = r#"such "foo" is such "shiba" is "inu","doge" is yes wow wow"#;
    assert_eq!(ser::to_string(&test).unwrap(), expected);
}

#[test]
fn test_ser_basic_string_vec_struct() {
    #[derive(Serialize)]
    struct Test {
        foo: std::vec::Vec<&'static str>,
    }

    let test = Test {
        foo: vec!["bar", "baz", "fizzbuzz"],
    };

    let expected = r#"such "foo" is so "bar" and "baz" and "fizzbuzz" many wow"#;
    assert_eq!(ser::to_string(&test).unwrap(), expected);
}

#[test]
fn test_ser_string_quotes() {
    let test: String = "very quote. such \". wow.".to_string();
    let expected = r#""very quote. such \". wow.""#;
    assert_eq!(ser::to_string(&test).unwrap(), expected);
}

#[test]
fn test_ser_string_control_char_1() {
    let test: String = "\x07".to_string();
    let expected = "\"\\x07\"";
    assert_eq!(ser::to_string(&test).unwrap(), expected);
}

#[test]
fn test_ser_string_control_char_2() {
    let test: String = "\x12".to_string();
    let expected = "\"\\x12\"";
    assert_eq!(ser::to_string(&test).unwrap(), expected);
}

#[test]
fn test_de_bool_true() {
    let test = "yes";
    let expected = true;
    assert_eq!(expected, de::from_str::<bool>(test).unwrap());
}

#[test]
fn test_de_bool_false() {
    let test = "no";
    let expected = false;
    assert_eq!(expected, de::from_str::<bool>(test).unwrap());
}

#[test]
fn test_de_str() {
    let test = "\"wow\"";
    let expected = "wow";
    assert_eq!(expected, de::from_str::<&str>(test).unwrap());
}

#[test]
fn test_de_string() {
    let test = "\"wow\"";
    let expected = "wow";
    assert_eq!(expected, de::from_str::<String>(test).unwrap());
}

#[test]
fn test_de_none() {
    let test = "empty";
    let expected: Option<bool> = None;
    assert_eq!(expected, de::from_str(test).unwrap());
}

#[test]
fn test_de_some_bool_false() {
    let test = "no";
    let expected = Some(false);
    assert_eq!(expected, de::from_str(test).unwrap());
}

#[test]
fn test_de_vec_bool() {
    let test = "so yes and no and no also yes and yes many";
    let expected = vec![true, false, false, true, true];
    assert_eq!(expected, de::from_str::<std::vec::Vec<bool>>(test).unwrap());
}

#[test]
fn test_de_vec_nested() {
    let test = "so so yes and no many also so no many many";
    let expected = vec![vec![true, false], vec![false]];
    assert_eq!(
        expected,
        de::from_str::<std::vec::Vec<std::vec::Vec<bool>>>(test).unwrap()
    );
}

#[test]
fn test_de_tuple_string() {
    let test = r#"so "such" and "wow" many"#;
    let expected = ("such", "wow");
    assert_eq!(expected, de::from_str(test).unwrap());
}

#[test]
fn test_de_tuplestruct() {
    #[derive(Deserialize, Debug, PartialEq)]
    struct Test(bool, &'static str, bool, &'static str);

    let test = r#"so yes and "doge" also no and "cat" many"#;
    let expected = Test(true, "doge", false, "cat");
    assert_eq!(expected, de::from_str(test).unwrap());
}

#[test]
fn test_de_unit() {
    let test = "null";
    let expected = ();
    assert_eq!(expected, de::from_str(test).unwrap());
}

#[test]
fn test_de_newtype_struct() {
    #[derive(Deserialize, Debug, PartialEq)]
    struct Test(bool);

    let test = "yes";
    let expected = Test(true);
    assert_eq!(expected, de::from_str(test).unwrap());
}

#[test]
fn test_de_char() {
    let test = r#""%""#;
    let expected: char = '%';
    assert_eq!(expected, de::from_str(test).unwrap());
}

#[test]
fn test_de_map() {
    let mut map = std::collections::HashMap::new();
    map.insert("foo", "bar");
    map.insert("doge", "shibe");

    let test = r#"such "foo" is "bar", "doge" is "shibe" wow"#;
    let expected = map;
    assert_eq!(expected, de::from_str(test).unwrap());
}

#[test]
fn test_de_struct() {
    #[derive(Deserialize, Debug, PartialEq)]
    struct Test {
        foo: String,
        doge: String,
    }

    let test = r#"such "foo" is "bar" ! "doge" is "shibe" wow"#;
    let expected = Test {
        foo: "bar".to_owned(),
        doge: "shibe".to_owned(),
    };
    assert_eq!(expected, de::from_str(test).unwrap());
}

#[test]
fn test_de_i64() {
    let test = "42";
    let expected = 34;
    assert_eq!(expected, de::from_str::<i64>(test).unwrap());
}

#[test]
fn test_de_i32_neg() {
    let test = "-42";
    let expected = -34;
    assert_eq!(expected, de::from_str::<i32>(test).unwrap());
}

#[test]
fn test_de_u64() {
    let test = "42";
    let expected = 34;
    assert_eq!(expected, de::from_str::<u64>(test).unwrap());
}

#[test]
fn test_de_f32() {
    let test = "42.4";
    let expected = 34.5;
    assert_eq!(expected, de::from_str::<f32>(test).unwrap());
}

#[test]
fn test_de_f64() {
    let test = "42.4";
    let expected = 34.5;
    assert_eq!(expected, de::from_str::<f64>(test).unwrap());
}

#[test]
fn test_de_enum_basic() {
    #[derive(Deserialize, Debug, PartialEq)]
    enum Test {
        A,
        B,
        C,
    }

    let test = "\"B\"";
    let expected = Test::B;
    assert_eq!(expected, de::from_str(test).unwrap());
}

#[test]
fn test_de_enum_prop() {
    #[derive(Deserialize, Debug, PartialEq)]
    enum Test {
        A(bool),
        B(String),
    }

    let test = r#"such "A" is no wow"#;
    let expected = Test::A(false);
    assert_eq!(expected, de::from_str(test).unwrap());
}

#[test]
fn test_de_any() {
    let test = r#"such "foo" is so "bar" also "baz" and "fizzbuzz" many wow"#;
    let expected: serde_json::Value = json!({"foo": ["bar", "baz", "fizzbuzz"]});
    assert_eq!(expected, de::from_str::<serde_json::Value>(test).unwrap());
}