dxr 0.8.0

use crate::{TryFromParams, TryToParams, Value};

#[test]
fn to_value() {
    let value = vec![Value::Integer(42)];
    let expected = Value::Integer(42);

    assert_eq!(Value::try_from_params(&value).unwrap(), expected);
}

#[test]
fn from_value() {
    let value = Value::Integer(42);
    let expected = vec![Value::Integer(42)];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn from_value_ref() {
    let value = Value::Integer(42);
    let expected = vec![Value::Integer(42)];

    assert_eq!(<&Value>::try_to_params(&&value).unwrap(), expected);
}

#[test]
fn to_i4() {
    let value = vec![Value::Integer(-12)];
    let expected = -12i32;

    assert_eq!(i32::try_from_params(&value).unwrap(), expected);
}

#[test]
fn from_i4() {
    let value = -12i32;
    let expected = vec![Value::Integer(-12)];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[cfg(feature = "i8")]
#[test]
fn to_i8() {
    let value = vec![Value::Long(-12)];
    let expected = -12i64;

    assert_eq!(i64::try_from_params(&value).unwrap(), expected);
}

#[cfg(feature = "i8")]
#[test]
fn from_i8() {
    let value = -12i64;
    let expected = vec![Value::Long(-12)];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn to_boolean() {
    let value = vec![Value::Boolean(true)];
    let expected = true;

    assert_eq!(bool::try_from_params(&value).unwrap(), expected);
}

#[test]
fn from_boolean() {
    let value = false;
    let expected = vec![Value::Boolean(false)];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn to_str() {
    let expected = "HELLO";
    let value = vec![Value::String(String::from(expected))];

    assert_eq!(String::try_from_params(&value).unwrap(), expected);
}

#[test]
fn from_str() {
    let value = "WORLD";
    let expected = vec![Value::String(String::from(value))];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn from_string() {
    let value = String::from("WORLD");
    let expected = vec![Value::String(value.clone())];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[allow(clippy::float_cmp)]
#[test]
fn to_double() {
    let value = vec![Value::Double(-2.5)];
    let expected = -2.5f64;

    assert_eq!(f64::try_from_params(&value).unwrap(), expected);
}

#[test]
fn from_double() {
    let value = -2.5f64;
    let expected = vec![Value::Double(-2.5)];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[cfg(feature = "chrono")]
#[test]
fn to_datetime() {
    use crate::DateTime;
    use chrono::{SubsecRound, Utc};

    let expected = DateTime::from(Utc::now().round_subsecs(0).naive_utc());
    let value = vec![Value::DateTime(expected)];

    assert_eq!(DateTime::try_from_params(&value).unwrap(), expected);
}

#[cfg(feature = "chrono")]
#[test]
fn from_from_datetimedouble() {
    use crate::DateTime;
    use chrono::{SubsecRound, Utc};

    let value = DateTime::from(Utc::now().round_subsecs(0).naive_utc());
    let expected = vec![Value::DateTime(value)];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn to_base64() {
    let expected = b"you can't read this!".to_vec();
    let value = vec![Value::Base64(expected.clone())];

    assert_eq!(<Vec<u8>>::try_from_params(&value).unwrap(), expected);
}

#[test]
fn from_base64() {
    let value = b"you can't read this!".to_vec();
    let expected = vec![Value::Base64(value.clone())];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn from_base64_slice() {
    let value = b"you can't read this!";
    let expected = vec![Value::Base64(value.to_vec())];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn from_base64_array() {
    let value = b"you can't read this!".to_owned();
    let expected = vec![Value::Base64(value.to_vec())];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[cfg(feature = "nil")]
#[test]
fn to_nil_none() {
    let value = vec![Value::Nil];
    let expected = None;

    assert_eq!(<Option<i32>>::try_from_params(&value).unwrap(), expected);
}

#[cfg(feature = "nil")]
#[test]
fn to_nil_missing() {
    let value: Vec<Value> = Vec::new();
    let expected = None;

    assert_eq!(<Option<i32>>::try_from_params(&value).unwrap(), expected);
}

#[cfg(feature = "nil")]
#[test]
fn to_nil_some() {
    let value = vec![Value::Integer(1)];
    let expected = Some(1);

    assert_eq!(<Option<i32>>::try_from_params(&value).unwrap(), expected);
}

#[cfg(feature = "nil")]
#[test]
fn to_nil_fail() {
    let value = vec![Value::Integer(1), Value::Integer(2)];
    assert!(
        <Option<i32>>::try_from_params(&value)
            .unwrap_err()
            .is_parameter_mismatch()
    );
}

#[cfg(feature = "nil")]
#[test]
fn from_nil_none() {
    use crate::DateTime;

    let value: Option<DateTime> = None;
    let expected = vec![Value::Nil];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[cfg(feature = "nil")]
#[test]
fn from_nil_none_ref() {
    use crate::DateTime;

    let value: Option<DateTime> = None;
    let expected = vec![Value::Nil];

    assert_eq!(<&Option<DateTime>>::try_to_params(&&value).unwrap(), expected);
}

#[cfg(feature = "chrono")]
#[cfg(feature = "nil")]
#[test]
fn from_nil_some() {
    use crate::DateTime;
    use chrono::{SubsecRound, Utc};

    let dt = DateTime::from(Utc::now().round_subsecs(0).naive_utc());
    let value: Option<DateTime> = Some(dt);
    let expected = vec![Value::DateTime(dt)];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[cfg(feature = "chrono")]
#[cfg(feature = "nil")]
#[test]
fn from_nil_some_ref() {
    use crate::DateTime;
    use chrono::{SubsecRound, Utc};

    let dt = DateTime::from(Utc::now().round_subsecs(0).naive_utc());
    let value: Option<DateTime> = Some(dt);
    let expected = vec![Value::DateTime(dt)];

    assert_eq!(<&Option<DateTime>>::try_to_params(&&value).unwrap(), expected);
}

#[cfg(feature = "derive")]
#[test]
fn to_hashmap() {
    use crate::TryToValue;
    use std::collections::HashMap;

    #[derive(TryToValue)]
    struct Test {
        foo: i32,
    }

    let value = vec![Test { foo: -12 }.try_to_value().unwrap()];
    let mut expected = HashMap::new();
    expected.insert(String::from("foo"), -12);

    assert_eq!(HashMap::try_from_params(&value).unwrap(), expected);
}

#[cfg(feature = "derive")]
#[test]
fn from_hashmap() {
    use crate::TryToValue;
    use std::collections::HashMap;

    #[derive(TryToValue)]
    struct Test {
        foo: i32,
    }

    let mut value = HashMap::new();
    value.insert("foo", -12);
    let expected = vec![Test { foo: -12 }.try_to_value().unwrap()];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn to_vec() {
    let value = vec![Value::Integer(8), Value::Integer(16)];
    let expected = vec![8, 16];

    assert_eq!(<Vec<i32>>::try_from_params(&value).unwrap(), expected);
}

#[test]
fn from_vec() {
    let value = vec![8, 16];
    let expected = vec![Value::Integer(8), Value::Integer(16)];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn to_unit() {
    let value = Vec::new();
    <()>::try_from_params(&value).unwrap();
}

#[test]
fn to_unit_fail() {
    let value = vec![Value::Integer(-1)];
    assert!(<()>::try_from_params(&value).unwrap_err().is_parameter_mismatch());
}

#[test]
fn from_unit() {
    let expected = Vec::new();
    assert_eq!(().try_to_params().unwrap(), expected);
}

#[test]
fn to_tuple_1() {
    let value = vec![Value::Boolean(true)];
    let expected = (true,);

    assert_eq!(<(bool,)>::try_from_params(&value).unwrap(), expected);
}

#[test]
fn from_tuple_1() {
    let value = (true,);
    let expected = vec![Value::Boolean(true)];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn to_tuple_2() {
    let value = vec![Value::Boolean(true), Value::Integer(1)];
    let expected = (true, 1);

    assert_eq!(<(bool, i32)>::try_from_params(&value).unwrap(), expected);
}

#[test]
fn from_tuple_2() {
    let value = (true, 1);
    let expected = vec![Value::Boolean(true), Value::Integer(1)];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn to_tuple_3() {
    let value = vec![Value::Boolean(true), Value::Integer(1), Value::Double(2.5)];
    let expected = (true, 1, 2.5);

    assert_eq!(<(bool, i32, f64)>::try_from_params(&value).unwrap(), expected);
}

#[test]
fn from_tuple_3() {
    let value = (true, 1, 2.5);
    let expected = vec![Value::Boolean(true), Value::Integer(1), Value::Double(2.5)];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn to_tuple_4() {
    let value = vec![
        Value::Boolean(true),
        Value::Integer(1),
        Value::Double(2.5),
        Value::String(String::from("HELLO")),
    ];
    let expected = (true, 1, 2.5, String::from("HELLO"));

    assert_eq!(<(bool, i32, f64, String)>::try_from_params(&value).unwrap(), expected);
}

#[test]
fn from_tuple_4() {
    let value = (true, 1, 2.5, String::from("HELLO"));
    let expected = vec![
        Value::Boolean(true),
        Value::Integer(1),
        Value::Double(2.5),
        Value::String(String::from("HELLO")),
    ];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn to_tuple_5() {
    let value = vec![
        Value::Boolean(true),
        Value::Integer(1),
        Value::Double(2.5),
        Value::String(String::from("HELLO")),
        Value::Boolean(false),
    ];
    let expected = (true, 1, 2.5, String::from("HELLO"), false);

    assert_eq!(
        <(bool, i32, f64, String, bool)>::try_from_params(&value).unwrap(),
        expected
    );
}

#[test]
fn from_tuple_5() {
    let value = (true, 1, 2.5, String::from("HELLO"), false);
    let expected = vec![
        Value::Boolean(true),
        Value::Integer(1),
        Value::Double(2.5),
        Value::String(String::from("HELLO")),
        Value::Boolean(false),
    ];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn to_tuple_6() {
    let value = vec![
        Value::Boolean(true),
        Value::Integer(1),
        Value::Double(2.5),
        Value::String(String::from("HELLO")),
        Value::Boolean(false),
        Value::Integer(2),
    ];
    let expected = (true, 1, 2.5, String::from("HELLO"), false, 2);

    assert_eq!(
        <(bool, i32, f64, String, bool, i32)>::try_from_params(&value).unwrap(),
        expected
    );
}

#[test]
fn from_tuple_6() {
    let value = (true, 1, 2.5, String::from("HELLO"), false, 2);
    let expected = vec![
        Value::Boolean(true),
        Value::Integer(1),
        Value::Double(2.5),
        Value::String(String::from("HELLO")),
        Value::Boolean(false),
        Value::Integer(2),
    ];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn to_tuple_7() {
    let value = vec![
        Value::Boolean(true),
        Value::Integer(1),
        Value::Double(2.5),
        Value::String(String::from("HELLO")),
        Value::Boolean(false),
        Value::Integer(2),
        Value::Double(-1.5),
    ];
    let expected = (true, 1, 2.5, String::from("HELLO"), false, 2, -1.5);

    assert_eq!(
        <(bool, i32, f64, String, bool, i32, f64)>::try_from_params(&value).unwrap(),
        expected
    );
}

#[test]
fn from_tuple_7() {
    let value = (true, 1, 2.5, String::from("HELLO"), false, 2, -1.5);
    let expected = vec![
        Value::Boolean(true),
        Value::Integer(1),
        Value::Double(2.5),
        Value::String(String::from("HELLO")),
        Value::Boolean(false),
        Value::Integer(2),
        Value::Double(-1.5),
    ];

    assert_eq!(value.try_to_params().unwrap(), expected);
}

#[test]
fn to_tuple_8() {
    let value = vec![
        Value::Boolean(true),
        Value::Integer(1),
        Value::Double(2.5),
        Value::String(String::from("HELLO")),
        Value::Boolean(false),
        Value::Integer(2),
        Value::Double(-1.5),
        Value::String(String::from("WORLD")),
    ];
    let expected = (
        true,
        1,
        2.5,
        String::from("HELLO"),
        false,
        2,
        -1.5,
        String::from("WORLD"),
    );

    assert_eq!(
        <(bool, i32, f64, String, bool, i32, f64, String)>::try_from_params(&value).unwrap(),
        expected
    );
}

#[test]
fn from_tuple_8() {
    let value = (
        true,
        1,
        2.5,
        String::from("HELLO"),
        false,
        2,
        -1.5,
        String::from("WORLD"),
    );
    let expected = vec![
        Value::Boolean(true),
        Value::Integer(1),
        Value::Double(2.5),
        Value::String(String::from("HELLO")),
        Value::Boolean(false),
        Value::Integer(2),
        Value::Double(-1.5),
        Value::String(String::from("WORLD")),
    ];

    assert_eq!(value.try_to_params().unwrap(), expected);
}