rust_flightplan 1.1.1

////////////////////////////////////////////////////////////////////////////////////////////////////
// MIT License                                                                                     /
//                                                                                                 /
// Copyright (c) 2024 Rust-FlightPlan Team                                                         /
//                                                                                                 /
// Permission is hereby granted, free of charge, to any person obtaining a copy                    /
// of this software and associated documentation files (the "Software"), to deal                   /
// in the Software without restriction, including without limitation the rights                    /
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell                       /
// copies of the Software, and to permit persons to whom the Software is                           /
// furnished to do so, subject to the following conditions:                                        /
//                                                                                                 /
// The above copyright notice and this permission notice shall be included in all                  /
// copies or substantial portions of the Software.                                                 /
//                                                                                                 /
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR                      /
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,                        /
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE                     /
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER                          /
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,                   /
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE                   /
// SOFTWARE.                                                                                       /
////////////////////////////////////////////////////////////////////////////////////////////////////

use chrono::{DateTime, Utc};
use serde::de::{self, Unexpected};
use serde::{Deserialize, Deserializer};

pub(crate) fn bool_from_str<'de, D>(deserializer: D) -> Result<bool, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer)?.to_lowercase().as_str() {
        "1" | "yes" => Ok(true),
        "0" | "no" => Ok(false),
        other => Err(de::Error::invalid_value(
            Unexpected::Str(other),
            &"Input must be either 0, 1, yes or no",
        )),
    }
}

fn _vec_string_from_string<'de, D>(deserializer: D) -> Result<Vec<String>, D::Error>
where
    D: Deserializer<'de>,
{
    let keywords = String::deserialize(deserializer)?;
    match keywords.len() {
        0 => Ok(vec![]),
        _ => Ok(keywords.split(',').map(|s| s.trim().to_string()).collect()),
    }
}

pub(crate) fn u8_from_str<'de, D>(deserializer: D) -> Result<u8, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let result: Result<u8, _> = input.parse();
    if let Ok(value) = result {
        Ok(value)
    } else {
        Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a String with a single u8",
        ))
    }
}

pub(crate) fn u16_from_str<'de, D>(deserializer: D) -> Result<u16, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let result: Result<u16, _> = input.parse();
    if let Ok(value) = result {
        Ok(value)
    } else {
        Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a String with a single u16",
        ))
    }
}

pub(crate) fn u32_from_str<'de, D>(deserializer: D) -> Result<u32, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let result: Result<u32, _> = input.parse();
    if let Ok(value) = result {
        Ok(value)
    } else {
        Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a String with a single u32",
        ))
    }
}

pub(crate) fn _u64_from_str<'de, D>(deserializer: D) -> Result<u64, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let result: Result<u64, _> = input.parse();
    if let Ok(value) = result {
        Ok(value)
    } else {
        Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a String with a single u64",
        ))
    }
}

pub(crate) fn _u128_from_str<'de, D>(deserializer: D) -> Result<u128, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let result: Result<u128, _> = input.parse();
    if let Ok(value) = result {
        Ok(value)
    } else {
        Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a String with a single u128",
        ))
    }
}

pub(crate) fn i8_from_str<'de, D>(deserializer: D) -> Result<i8, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let result: Result<i8, _> = input.parse();
    if let Ok(value) = result {
        Ok(value)
    } else {
        Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a String with a single i8",
        ))
    }
}

pub(crate) fn i16_from_str<'de, D>(deserializer: D) -> Result<i16, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let result: Result<i16, _> = input.parse();
    if let Ok(value) = result {
        Ok(value)
    } else {
        Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a String with a single i16",
        ))
    }
}

pub(crate) fn i32_from_str<'de, D>(deserializer: D) -> Result<i32, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let result: Result<i32, _> = input.parse();
    if let Ok(value) = result {
        Ok(value)
    } else {
        Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a String with a single i32",
        ))
    }
}

pub(crate) fn _i64_from_str<'de, D>(deserializer: D) -> Result<i64, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let result: Result<i64, _> = input.parse();
    if let Ok(value) = result {
        Ok(value)
    } else {
        Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a String with a single i64",
        ))
    }
}

pub(crate) fn _i128_from_str<'de, D>(deserializer: D) -> Result<i128, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let result: Result<i128, _> = input.parse();
    if let Ok(value) = result {
        Ok(value)
    } else {
        Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a String with a single i128",
        ))
    }
}

pub(crate) fn f32_from_str<'de, D>(deserializer: D) -> Result<f32, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let result: Result<f32, _> = input.parse();
    if let Ok(value) = result {
        Ok(value)
    } else {
        Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a String with a single f32",
        ))
    }
}

pub(crate) fn f64_from_str<'de, D>(deserializer: D) -> Result<f64, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let result: Result<f64, _> = input.parse();
    if let Ok(value) = result {
        Ok(value)
    } else {
        Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a String with a single f64",
        ))
    }
}

pub(crate) fn option_u8_from_str<'de, D>(deserializer: D) -> Result<Option<u8>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let result: Result<u8, _> = input.parse();
            if let Ok(value) = result {
                Ok(Some(value))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single u8",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn option_u16_from_str<'de, D>(deserializer: D) -> Result<Option<u16>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let result: Result<u16, _> = input.parse();
            if let Ok(value) = result {
                Ok(Some(value))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single u16",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn option_u32_from_str<'de, D>(deserializer: D) -> Result<Option<u32>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let result: Result<u32, _> = input.parse();
            if let Ok(value) = result {
                Ok(Some(value))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single u32",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn _option_u64_from_str<'de, D>(deserializer: D) -> Result<Option<u64>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let result: Result<u64, _> = input.parse();
            if let Ok(value) = result {
                Ok(Some(value))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single u64",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn _option_u128_from_str<'de, D>(deserializer: D) -> Result<Option<u128>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let result: Result<u128, _> = input.parse();
            if let Ok(value) = result {
                Ok(Some(value))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single u128",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn option_i8_from_str_wind_comp<'de, D>(deserializer: D) -> Result<Option<i8>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let sign = &input[..1];
            let number = &input[1..];
            let result: Result<i8, _> = number.parse();
            if let Ok(value) = result {
                let finish: i8 = if sign.eq("P") { value } else { -value };
                Ok(Some(finish))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single i8 with a \"P\" or \"M\" in front of it",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn _option_i8_from_str<'de, D>(deserializer: D) -> Result<Option<i8>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let result: Result<i8, _> = input.parse();
            if let Ok(value) = result {
                Ok(Some(value))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single i8",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn _option_i16_from_str<'de, D>(deserializer: D) -> Result<Option<i16>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let result: Result<i16, _> = input.parse();
            if let Ok(value) = result {
                Ok(Some(value))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single i16",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn _option_i32_from_str<'de, D>(deserializer: D) -> Result<Option<i32>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let result: Result<i32, _> = input.parse();
            if let Ok(value) = result {
                Ok(Some(value))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single i32",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn _option_i64_from_str<'de, D>(deserializer: D) -> Result<Option<i64>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let result: Result<i64, _> = input.parse();
            if let Ok(value) = result {
                Ok(Some(value))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single i64",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn _option_i128_from_str<'de, D>(deserializer: D) -> Result<Option<i128>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let result: Result<i128, _> = input.parse();
            if let Ok(value) = result {
                Ok(Some(value))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single i128",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn _option_f32_from_str<'de, D>(deserializer: D) -> Result<Option<f32>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let result: Result<f32, _> = input.parse();
            if let Ok(value) = result {
                Ok(Some(value))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single f32",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn option_f64_from_str<'de, D>(deserializer: D) -> Result<Option<f64>, D::Error>
where
    D: Deserializer<'de>,
{
    match String::deserialize(deserializer) {
        Ok(input) => {
            let result: Result<f64, _> = input.parse();
            if let Ok(value) = result {
                Ok(Some(value))
            } else {
                Err(de::Error::invalid_value(
                    Unexpected::Str(&input),
                    &"Input must be a String with a single f64",
                ))
            }
        }
        Err(_) => Ok(None),
    }
}

pub(crate) fn ts_from_string<'de, D>(deserializer: D) -> Result<DateTime<Utc>, D::Error>
where
    D: Deserializer<'de>,
{
    let input = String::deserialize(deserializer)?;
    let input_parsed: Result<i64, _> = input.parse();
    match input_parsed {
        Ok(timestamp) => Ok(DateTime::<Utc>::from_timestamp(timestamp, 0)
            .unwrap()
            .to_utc()),
        Err(_) => Err(de::Error::invalid_value(
            Unexpected::Str(&input),
            &"Input must be a valid timestamp",
        )),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::TimeZone;
    use serde_json::Deserializer;

    #[test]
    fn test_bool_from_str() {
        let mut de = Deserializer::from_str("\"yes\"");
        assert!(bool_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"1\"");
        assert!(bool_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"no\"");
        assert!(!bool_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"0\"");
        assert!(!bool_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"test\"");
        assert!(bool_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"YeS\"");
        assert!(bool_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"NO\"");
        assert!(!bool_from_str(&mut de).unwrap());
    }

    #[test]
    fn test_vec_string_from_string() {
        let mut de = Deserializer::from_str("\"yes, no\"");
        assert_eq!(vec!("yes", "no"), _vec_string_from_string(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes,no\"");
        assert_eq!(vec!("yes", "no"), _vec_string_from_string(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert_eq!(vec!("yes"), _vec_string_from_string(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"\"");
        assert!(_vec_string_from_string(&mut de).unwrap().is_empty());
    }

    #[test]
    fn test_u8_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8u8, u8_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(u8_from_str(&mut de).is_err());
    }

    #[test]
    fn test_u16_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8u16, u16_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(u8_from_str(&mut de).is_err());
    }

    #[test]
    fn test_u32_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8u32, u32_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(u8_from_str(&mut de).is_err());
    }

    #[test]
    fn test_u64_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8u64, _u64_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(u8_from_str(&mut de).is_err());
    }

    #[test]
    fn test_u128_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8u128, _u128_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(u8_from_str(&mut de).is_err());
    }

    #[test]
    fn test_i8_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8i8, i8_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8i8, i8_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(u8_from_str(&mut de).is_err());
    }

    #[test]
    fn test_i16_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8i16, i16_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8i16, i16_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(u8_from_str(&mut de).is_err());
    }

    #[test]
    fn test_i32_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8i32, i32_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8i32, i32_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(u8_from_str(&mut de).is_err());
    }

    #[test]
    fn test_i64_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8i64, _i64_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8i64, _i64_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(u8_from_str(&mut de).is_err());
    }

    #[test]
    fn test_i128_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8i128, _i128_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8i128, _i128_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(u8_from_str(&mut de).is_err());
    }

    #[test]
    fn test_f32_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8f32, f32_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"8.5\"");
        assert_eq!(8.5f32, f32_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8f32, f32_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"-8.5\"");
        assert_eq!(-8.5f32, f32_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(u8_from_str(&mut de).is_err());
    }

    #[test]
    fn test_f64_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8f64, f64_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"8.5\"");
        assert_eq!(8.5f64, f64_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8f64, f64_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"-8.5\"");
        assert_eq!(-8.5f64, f64_from_str(&mut de).unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(u8_from_str(&mut de).is_err());
    }

    #[test]
    fn test_option_u8_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert!(option_u8_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8\"");
        assert!(option_u8_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8u8, option_u8_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(option_u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(option_u8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(option_u8_from_str(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_option_u16_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert!(option_u16_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8\"");
        assert!(option_u16_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8u16, option_u16_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(option_u16_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(option_u16_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(option_u16_from_str(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_option_u32_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert!(option_u32_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8\"");
        assert!(option_u32_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8u32, option_u32_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(option_u32_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(option_u32_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(option_u32_from_str(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_option_u64_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_u64_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_u64_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8u64, _option_u64_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(_option_u64_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(_option_u64_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(_option_u64_from_str(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_option_u128_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_u128_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_u128_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8u128, _option_u128_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(_option_u128_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(_option_u128_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(_option_u128_from_str(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_option_i8_from_str_wind_comp() {
        let mut de = Deserializer::from_str("\"P8\"");
        assert!(option_i8_from_str_wind_comp(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"P8\"");
        assert!(option_i8_from_str_wind_comp(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"P8\"");
        assert_eq!(8i8, option_i8_from_str_wind_comp(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"M8\"");
        assert!(option_i8_from_str_wind_comp(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"M8\"");
        assert!(option_i8_from_str_wind_comp(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"M8\"");
        assert_eq!(
            -8i8,
            option_i8_from_str_wind_comp(&mut de).unwrap().unwrap()
        );

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(option_i8_from_str_wind_comp(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(option_i8_from_str_wind_comp(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_option_i8_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_i8_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_i8_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8i8, _option_i8_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert!(_option_i8_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"-8\"");
        assert!(_option_i8_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8i8, _option_i8_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(_option_i8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(_option_i8_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(_option_i8_from_str(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_option_i16_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_i16_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_i16_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8i16, _option_i16_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert!(_option_i16_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"-8\"");
        assert!(_option_i16_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8i16, _option_i16_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(_option_i16_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(_option_i16_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(_option_i16_from_str(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_option_i32_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_i32_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_i32_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8i32, _option_i32_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert!(_option_i32_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"-8\"");
        assert!(_option_i32_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8i32, _option_i32_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(_option_i32_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(_option_i32_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(_option_i32_from_str(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_option_i64_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_i64_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_i64_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8i64, _option_i64_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert!(_option_i64_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"-8\"");
        assert!(_option_i64_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8i64, _option_i64_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(_option_i64_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(_option_i64_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(_option_i64_from_str(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_option_i128_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_i128_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_i128_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8i128, _option_i128_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert!(_option_i128_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"-8\"");
        assert!(_option_i128_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8i128, _option_i128_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(_option_i128_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(_option_i128_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(_option_i128_from_str(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_option_f32_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_f32_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8\"");
        assert!(_option_f32_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8f32, _option_f32_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"8.5\"");
        assert!(_option_f32_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8.5\"");
        assert!(_option_f32_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8.5\"");
        assert_eq!(8.5f32, _option_f32_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert!(_option_f32_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"-8\"");
        assert!(_option_f32_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8f32, _option_f32_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"-8.5\"");
        assert!(_option_f32_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"-8.5\"");
        assert!(_option_f32_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"-8.5\"");
        assert_eq!(-8.5f32, _option_f32_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(_option_f32_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(_option_f32_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(_option_f32_from_str(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_option_f64_from_str() {
        let mut de = Deserializer::from_str("\"8\"");
        assert!(option_f64_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8\"");
        assert!(option_f64_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8\"");
        assert_eq!(8f64, option_f64_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"8.5\"");
        assert!(option_f64_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"8.5\"");
        assert!(option_f64_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"8.5\"");
        assert_eq!(8.5f64, option_f64_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"-8\"");
        assert!(option_f64_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"-8\"");
        assert!(option_f64_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"-8\"");
        assert_eq!(-8f64, option_f64_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"-8.5\"");
        assert!(option_f64_from_str(&mut de).is_ok());
        let mut de = Deserializer::from_str("\"-8.5\"");
        assert!(option_f64_from_str(&mut de).unwrap().is_some());
        let mut de = Deserializer::from_str("\"-8.5\"");
        assert_eq!(-8.5f64, option_f64_from_str(&mut de).unwrap().unwrap());

        let mut de = Deserializer::from_str("\"yes\"");
        assert!(option_f64_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("\"\"");
        assert!(option_f64_from_str(&mut de).is_err());

        let mut de = Deserializer::from_str("");
        assert!(option_f64_from_str(&mut de).unwrap().is_none());
    }

    #[test]
    fn test_ts_from_string() {
        let mut de = Deserializer::from_str("\"1720719600\"");
        let date: DateTime<Utc> = Utc.with_ymd_and_hms(2024, 7, 11, 17, 40, 0).unwrap();
        assert_eq!(date, ts_from_string(&mut de).unwrap());
    }
}