valid_toml 0.0.2

/* Copyright 2016 Joshua Gentry
 *
 * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 * http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
 * <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 * option. This file may not be copied, modified, or distributed
 * except according to those terms.
 */

//*************************************************************************************************
/// Check for success
//*************************************************************************************************
macro_rules! assert_duration {
    ($result:expr, $val:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Item(item) => {
                match item
                {
                    ItemValue::Duration(val) => assert_eq!(val, $val),
                    _ => panic!("Expected Duration, got {:?} instead", item)
                }
             },
             _ => panic!("Expected Item got {:?} instead", result)
         }
    }};

    ($result:expr, $ms:expr) => {
        assert_duration!($result, $ms)
    };

    ($result:expr, $sec:expr, $ms:expr) => {
        assert_duration!($result, $sec * 1000 + $ms)
    };

    ($result:expr, $min:expr, $sec:expr, $ms:expr) => {
        assert_duration!($result, $min * 60 * 1000 + $sec * 1000 + $ms)
    };

    ($result:expr, $hour:expr, $min:expr, $sec:expr, $ms:expr) => {
        assert_duration!($result, $hour * 60 * 60 * 1000 + $min * 60 * 1000 + $sec * 1000 + $ms)
    };
}

macro_rules! assert_i64 {
    ($result:expr, $val:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Item(item) => {
                match item
                {
                    ItemValue::I64(val) => assert_eq!(val, $val),
                    _ => panic!("Expected I64, got {:?} instead", item)
                }
             },
             _ => panic!("Expected Item got {:?} instead", result)
         }
    }};
}

macro_rules! assert_string {
    ($result:expr, $val:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Item(item) => {
                match item
                {
                    ItemValue::String(val) => assert_eq!(val, $val),
                    _ => panic!("Expected String, got {:?} instead", item)
                }
             },
             _ => panic!("Expected Item got {:?} instead", result)
         }
    }};
}

macro_rules! assert_u16 {
    ($result:expr, $val:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Item(item) => {
                match item
                {
                    ItemValue::U16(val) => assert_eq!(val, $val),
                    _ => panic!("Expected U16, got {:?} instead", item)
                }
             },
             _ => panic!("Expected Item got {:?} instead", result)
         }
    }};
}

macro_rules! assert_usize {
    ($result:expr, $val:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Item(item) => {
                match item
                {
                    ItemValue::Usize(val) => assert_eq!(val, $val),
                    _ => panic!("Expected Usize, got {:?} instead", item)
                }
             },
             _ => panic!("Expected Item got {:?} instead", result)
         }
    }};
}

//*************************************************************************************************
/// Check for errors
//*************************************************************************************************
macro_rules! assert_cannot_parse {
    ($result:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Error(err) => {
                match err {
                    ValidationError::CannotParse(_) => {},
                    _ => panic!("Expected CannotParse got {:?}", err)
                }
            },
            _ => panic!("Expected Error got {:?}", result)
        }
    }}
}


macro_rules! assert_duration_overflow {
    ($result:expr, $max:expr) => {{
        let result = $result;

        match $result
        {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::DurationOverflow(r_min, r_max) => {
                        assert!(r_min.is_none());
                        assert_eq!(r_max.unwrap(), $max);
                    },
                    _ => panic!("Expected DurationOverflow, got {:?} instead", err)
                }
             },
             _ => panic!("Expected Error got {:?} instead", $result)
         }
     }};

     ($result:expr, $min:expr, $max:expr) => {{
         let result = $result;

         match result
         {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::DurationOverflow(r_min, r_max) => {
                        assert_eq!(r_min.unwrap(), $min);
                        assert_eq!(r_max.unwrap(), $max);
                    },
                    _ => panic!("Expected DurationOverflow, got {:?} instead", err)
                }
            },
            _ => panic!("Expected Error got {:?} instead", result)
        }
    }}
}

macro_rules! assert_duration_overflow {
    ($result:expr, $max:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::DurationOverflow(r_min, r_max) => {
                        assert!(r_min.is_none());
                        assert_eq!(r_max.unwrap(), $max);
                    },
                    _ => panic!("Expected DurationOverflow, got {:?} instead", err)
                }
            },
            _ => panic!("Expected Error got {:?} instead", result)
        }
    }};

    ($result:expr, $min:expr, $max:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::DurationOverflow(r_min, r_max) => {
                        assert_eq!(r_min.unwrap(), $min);
                        assert_eq!(r_max.unwrap(), $max);
                    },
                    _ => panic!("Expected DurationOverflow, got {:?} instead", err)
                }
            },
            _ => panic!("Expected Error got {:?} instead", result)
        }
    }}
}

macro_rules! assert_duration_underrun {
    ($result:expr, $min:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::DurationUnderrun(r_min, r_max) => {
                        assert_eq!(r_min.unwrap(), $min);
                        assert!(r_max.is_none());
                    },
                    _ => panic!("Expected DurationUnderrun, got {:?} instead", err)
                }
            },
            _ => panic!("Expected Error got {:?} instead", result)
        }
    }};

    ($result:expr, $min:expr, $max:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::DurationUnderrun(r_min, r_max) => {
                        assert_eq!(r_min.unwrap(), $min);
                        assert_eq!(r_max.unwrap(), $max);
                    },
                    _ => panic!("Expected DurationUnderrun, got {:?} instead", err)
                }
            },
            _ => panic!("Expected Error got {:?} instead", result)
        }
    }}
}

macro_rules! assert_incorrect_type {
    ($result:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Error(err) => {
                match err {
                    ValidationError::IncorrectType(_) => {},
                    _ => panic!("Expected IncorrectType got {:?}", err)
                }
            },
            _ => panic!("Expected Error got {:?}", result)
        }
    }}
}

macro_rules! assert_long {
    ($result:expr, $max:expr) => {{
        let result = $result;

        match $result
        {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::Long(r_min, r_max) => {
                        assert!(r_min.is_none());
                        assert_eq!(r_max.unwrap(), $max);
                    },
                    _ => panic!("Expected Long, got {:?} instead", err)
                }
             },
             _ => panic!("Expected Error got {:?} instead", result)
         }
     }};

     ($result:expr, $min:expr, $max:expr) => {{
         let result = $result;

         match result
         {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::Long(r_min, r_max) => {
                        assert_eq!(r_min.unwrap(), $min);
                        assert_eq!(r_max.unwrap(), $max);
                    },
                    _ => panic!("Expected Long, got {:?} instead", err)
                }
            },
            _ => panic!("Expected Error got {:?} instead", result)
        }
    }}
}

macro_rules! assert_overflow {
    ($result:expr, $max:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::Overflow(r_min, r_max) => {
                        assert!(r_min.is_none());
                        assert_eq!(r_max.unwrap(), $max);
                    },
                    _ => panic!("Expected Overflow, got {:?} instead", err)
                }
             },
             _ => panic!("Expected Error got {:?} instead", result)
         }
     }};

     ($result:expr, $min:expr, $max:expr) => {{
         let result = $result;

         match result
         {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::Overflow(r_min, r_max) => {
                        assert_eq!(r_min.unwrap(), $min);
                        assert_eq!(r_max.unwrap(), $max);
                    },
                    _ => panic!("Expected Overflow, got {:?} instead", err)
                }
            },
            _ => panic!("Expected Error got {:?} instead", result)
        }
    }}
}

macro_rules! assert_short {
    ($result:expr, $min:expr) => {{
        let result = $result;

        match $result
        {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::Short(r_min, r_max) => {
                        assert_eq!(r_min.unwrap(), $min);
                        assert!(r_max.is_none());
                    },
                    _ => panic!("Expected Short, got {:?} instead", err)
                }
             },
             _ => panic!("Expected Error got {:?} instead", result)
         }
     }};

     ($result:expr, $min:expr, $max:expr) => {{
         let result = $result;

         match result
         {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::Short(r_min, r_max) => {
                        assert_eq!(r_min.unwrap(), $min);
                        assert_eq!(r_max.unwrap(), $max);
                    },
                    _ => panic!("Expected Short, got {:?} instead", err)
                }
            },
            _ => panic!("Expected Error got {:?} instead", result)
        }
    }}
}

macro_rules! assert_underrun {
    ($result:expr, $min:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::Underrun(r_min, r_max) => {
                        assert_eq!(r_min.unwrap(), $min);
                        assert!(r_max.is_none());
                    },
                    _ => panic!("Expected Underrun, got {:?} instead", err)
                }
            },
            _ => panic!("Expected Error got {:?} instead", result)
        }
    }};

    ($result:expr, $min:expr, $max:expr) => {{
        let result = $result;

        match result
        {
            ExtractResult::Error(err) => {
                match err
                {
                    ValidationError::Underrun(r_min, r_max) => {
                        assert_eq!(r_min.unwrap(), $min);
                        assert_eq!(r_max.unwrap(), $max);
                    },
                    _ => panic!("Expected Underrun, got {:?} instead", err)
                }
            },
            _ => panic!("Expected Error got {:?} instead", result)
        }
    }}
}