//! Module providing utilities for dealing with ENDF-6 format reals.
//!
//! ENDF reals format is described in section `0.6.2` of ENDF-6 Formats
//! Manual.
//!
//! `ENDF-6 Formats Manual` available at
//! <https://www.nndc.bnl.gov/csewg/docs/endf-manual.pdf>
//!
//! # Format
//!
//! ENDF reals can be read with FORTRAN77 `E11.0` format specification.
//!
//! ENDF reals have the following format:
//!
//! ```text
//! endf_real = (space* sign? int_part (dec_sep frac_part (exp_sep sign exp_part)?)?){1..11}
//! space = ' '
//! sign = '-' | '+'
//! int_part = digit+
//! dec_sep = '.'
//! frac_part = digit+
//! exp_sep = 'e' | 'E'
//! exp_part = digit+
//! digit = ['0'-'9']
//! ```
//!
//! Format can be checked with [`ENDF_REAL_REGEX`].
//!
//! # Parsing ENDF-6 Format reals
//!
//! ```rust
//! use endf_format::real::ParseEndfRealError;
//! fn parse_endf_real(real: &str) -> Result<f64, ParseEndfRealError> {
//!     endf_format::real::parse(real)
//! }
//! ```
//!
//! [`ENDF_REAL_REGEX`]: constant.ENDF_REAL_REGEX.html

use std::error::Error;
use std::fmt::{Display, Formatter};

/// ENDF-6 format reals maximum length (characters).
pub const ENDF_REAL_MAX_LEN: usize = 11;

/// ENDF-6 format reals base.
pub const ENDF_REAL_RADIX: u32 = 10;

/// ENDF-6 format real regular expression.
///
/// Regular expression provided for checking [`parse`] input beforehand.
///
/// ```rust
/// use regex::Regex;
///
/// let regex = Regex::new(endf_format::real::ENDF_REAL_REGEX).unwrap();
/// let real = "-1.23456E+7";
/// assert!(regex.is_match(real));
/// let x = endf_format::real::parse(real).unwrap();
/// ```
///
/// [`parse`]: fn.parse.html
pub const ENDF_REAL_REGEX: &str = r"^[ ]*[+\-]?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE]?[+\-]\d+)?$";

/// Error returned when parsing ENDF-6 format reals failed.
///
/// `ParseEndfRealError` provides a [`kind()`] ([`ParseEndfRealErrorKind`]) method
/// if fine error handling is needed.
///
/// [`ParseEndfRealErrorKind`]: enum.ParseEndfRealErrorKind.html
/// [`kind()`]: struct.ParseEndfRealError.html#method.kind
#[derive(Debug)]
pub struct ParseEndfRealError {
    kind: ParseEndfRealErrorKind,
}

impl ParseEndfRealError {
    /// Returns the corresponding `ParseEndfRealErrorKind` for this error.
    pub fn kind(&self) -> ParseEndfRealErrorKind {
        self.kind
    }
}

impl Display for ParseEndfRealError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self.kind() {
            ParseEndfRealErrorKind::Empty => write!(f, "cannot parse ENDF real from empty string"),
            ParseEndfRealErrorKind::EmptyIntegerPart => {
                write!(f, "cannot parse ENDF real without integer part")
            }
            ParseEndfRealErrorKind::EmptyFractionalPart => {
                write!(f, "cannot parse ENDF real without fractional part")
            }
            ParseEndfRealErrorKind::EmptyExponentPart => {
                write!(f, "cannot parse ENDF real without exponent part")
            }
            ParseEndfRealErrorKind::InvalidDecimalSeparator(x) => write!(
                f,
                "cannort parse ENDF real, found invalid decimal separator in string: {}",
                x.escape_default().collect::<String>()
            ),
            ParseEndfRealErrorKind::InvalidExponentSeparator(x) => write!(
                f,
                "cannort parse ENDF real, found invalid exponent separator in string: {}",
                x.escape_default().collect::<String>()
            ),
            ParseEndfRealErrorKind::InvalidExponentSign(x) => write!(
                f,
                "cannort parse ENDF real, found invalid exponent sign in string: {}",
                x.escape_default().collect::<String>()
            ),
            ParseEndfRealErrorKind::InvalidSign(x) => write!(
                f,
                "cannort parse ENDF real, found invalid sign in string: {}",
                x.escape_default().collect::<String>()
            ),
            ParseEndfRealErrorKind::NonAscii => {
                write!(f, "cannot parse ENDF real from non ASCII string")
            }
            ParseEndfRealErrorKind::Tail => {
                write!(f, "cannot parse ENDF real from string with tail")
            }
            ParseEndfRealErrorKind::TooLong => write!(f, "cannot parse ENDF real, string too long"),
        }
    }
}

impl Error for ParseEndfRealError {}

/// Non exhaustive list of errors that can occur while parsing ENDF reals.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[non_exhaustive]
pub enum ParseEndfRealErrorKind {
    Empty,
    EmptyIntegerPart,
    EmptyFractionalPart,
    EmptyExponentPart,
    InvalidDecimalSeparator(char),
    InvalidExponentSeparator(char),
    InvalidExponentSign(char),
    InvalidSign(char),
    NonAscii,
    Tail,
    TooLong,
}

/// Parse ENDF-6 Format real.
///
/// # Format
///
/// ENDF reals can be read with FORTRAN77 `E11.0` format specification.
///
/// ENDF reals have the following format:
///
/// ```text
/// endf_real = (space* sign? int_part (dec_sep frac_part (exp_sep sign exp_part)?)?){1..11}
/// space = ' '
/// sign = '-' | '+'
/// int_part = digit+
/// dec_sep = '.'
/// frac_part = digit+
/// exp_sep = 'e' | 'E'
/// exp_part = digit+
/// digit = ['0'-'9']
/// ```
///
/// # Equivalence tables
///
/// | Format        | Value          | Max exponent  | Digits        | Comment                              |
/// |---------------|----------------|:-------------:|:-------------:|--------------------------------------|
/// | `±nnnnnnnnnn` | `±nnnnnnnnnn`  | N/A           | 10            | integer                              |
/// | `±n.nnnnnnnn` | `±n.nnnnnnnn`  | N/A           | 9             | decimal                              |
/// | `±n.nnnnnE±d` | `±n.nnnnnE±d`  | 9             | 6             | scientific, 1-digit exponent         |
/// | `±n.nnnnnn±d` | `±n.nnnnnn±d`  | 9             | 7             | scientific, E-less, 1-digit exponent |
/// | `±n.nnnnE±dd` | `±n.nnnnE±dd`  | 38            | 5             | scientific, 2-digits exponent        |
/// | `±n.nnnnn±dd` | `±n.nnnnn±dd`  | 38            | 6             | scientific, E-less, 2-digits exponent|
///
/// | ENDF literal  | Rust literal         |
/// |---------------|----------------------|
/// | `0.123456789` | `0.123_456_789_f64`  |
/// | `1.2345678-9` | `1.234_567_8e-9_f64` |
/// | `1.234567e-9` | `1.234_567e-9_f64`   |
/// | `1.234567-12` | `1.234_567e-12_f64`  |
/// | `1.23456e-12` | `1.234_56e-12_f64`   |
///
/// # Example
///
/// ```rust
/// let x = endf_format::real::parse("-1.234567-1");
/// let diff = (-1.234567e-1_f64 - x.unwrap()).abs();
/// assert!(diff < 1e-10);
/// ```
///
/// # Details
///
/// This function trims the specified string and handle only ASCII input.
/// Following is redundant and should be avoided:
///
/// ```rust
/// let real = "-1.234567-1";
/// if real.is_ascii() {
/// //      ^^^^^^^^^^ redundant check
///     let x = endf_format::real::parse(real.trim());
/// //                                        ^^^^ redundant trim
/// }
/// ```
///
/// # Errors
///
/// A [`ParseEndfRealError`] is returned if the specified string could not be
/// parsed.
///
/// ## Empty
///
/// Empty/Blank strings are rejected.
///
/// ```rust
/// use endf_format::real::ParseEndfRealErrorKind;
///
/// // empty
/// let x = endf_format::real::parse("");
/// assert!(x.is_err());
/// assert_eq!(x.unwrap_err().kind(), ParseEndfRealErrorKind::Empty);
///
/// // blank
/// let y = endf_format::real::parse(" \t\n\r");
/// //                                ^ space char
/// assert!(y.is_err());
/// assert_eq!(y.unwrap_err().kind(), ParseEndfRealErrorKind::Empty);
/// ```
///
/// ## Empty parts
///
/// Empty integer/fractiona/exponent part(s) are rejected.
///
/// ```rust
/// use endf_format::real::ParseEndfRealErrorKind;
///
/// // empty integer part
/// let x = endf_format::real::parse("-.123456");
/// assert!(x.is_err());
/// assert_eq!(x.unwrap_err().kind(), ParseEndfRealErrorKind::EmptyIntegerPart);
///
/// // empty fractional part
/// let y = endf_format::real::parse("1.e5");
/// assert!(y.is_err());
/// assert_eq!(y.unwrap_err().kind(), ParseEndfRealErrorKind::EmptyFractionalPart);
///
/// // empty exponent part
/// let z = endf_format::real::parse("1.2345e");
/// assert!(z.is_err());
/// assert_eq!(z.unwrap_err().kind(), ParseEndfRealErrorKind::EmptyExponentPart);
/// ```
///
/// ## Invalid signs
///
/// Invalid signs are rejected.
///
/// ```rust
/// use endf_format::real::ParseEndfRealErrorKind;
///
/// // invalid sign
/// let x = endf_format::real::parse("%1.23456");
/// assert!(x.is_err());
/// assert_eq!(x.unwrap_err().kind(), ParseEndfRealErrorKind::InvalidSign('%'));
///
/// // invalid exponent sign
/// let y = endf_format::real::parse("-12.345e%3");
/// assert!(y.is_err());
/// assert_eq!(y.unwrap_err().kind(), ParseEndfRealErrorKind::InvalidExponentSign('%'));
/// ```
///
/// ## Invalid separators
///
/// Invalid decimal/exponent separator are rejected.
///
/// ```rust
/// use endf_format::real::ParseEndfRealErrorKind;
///
/// // invalid decimal separator
/// let x = endf_format::real::parse("1,23456e+12");
/// assert!(x.is_err());
/// assert_eq!(x.unwrap_err().kind(), ParseEndfRealErrorKind::InvalidDecimalSeparator(','));
///
/// // invalid exponent separator
/// let y = endf_format::real::parse("1.23456d+12");
/// assert!(y.is_err());
/// assert_eq!(y.unwrap_err().kind(), ParseEndfRealErrorKind::InvalidExponentSeparator('d'));
/// ```
///
/// ## Non ASCII
///
/// ENDF-6 format allows only ASCII characters. This method fail-fast on non
/// ASCII input.
///
/// ```rust
/// use endf_format::real::ParseEndfRealErrorKind;
/// let x = endf_format::real::parse("\u{1F600}");
/// assert!(x.is_err());
/// assert_eq!(x.unwrap_err().kind(), ParseEndfRealErrorKind::NonAscii);
/// ```
///
/// ## TooLarge
///
/// Too large number/string are rejected.
///
/// ```rust
/// use endf_format::real::ParseEndfRealErrorKind;
///
/// // too large, 12 (> 11) characters
/// let x = endf_format::real::parse("-1.23456e+12");
/// assert!(x.is_err());
/// assert_eq!(x.unwrap_err().kind(), ParseEndfRealErrorKind::TooLong);
/// ```
///
/// # Regex
///
/// Validating input is possible with [`ENDF_REAL_REGEX`]:
///
/// ```rust
/// use regex::Regex;
///
/// let regex = Regex::new(endf_format::real::ENDF_REAL_REGEX).unwrap();
/// assert!(regex.is_match("-1.23456e+12"));
/// ```
///
/// # Reference
///
/// ENDF real format is described in section `0.6.2` of
/// [ENDF-6 Formats Manual](https://www.nndc.bnl.gov/csewg/docs/endf-manual.pdf)
///
/// [`ENDF_REAL_REGEX`]: constant.ENDF_REAL_REGEX.html
/// [`ParseEndfRealError`]: struct.ParseEndfRealError.html
pub fn parse(real: &str) -> Result<f64, ParseEndfRealError> {
    if !real.is_ascii() {
        return Err(ParseEndfRealError {
            kind: ParseEndfRealErrorKind::NonAscii,
        });
    }
    // real is ASCII => (iteration over chars <=> iteration over bytes)
    let bytes = real.trim().as_bytes();
    if bytes.len() > ENDF_REAL_MAX_LEN {
        return Err(ParseEndfRealError {
            kind: ParseEndfRealErrorKind::TooLong,
        });
    }
    // bytes.len() <= ENDF_REAL_MAX_LEN (=11) => mantissa will not overflow i64
    // extract sign
    let (neg, tail) = match bytes.first() {
        Some(&b'-') => (true, &bytes[1..]),
        Some(&b'+') => (false, &bytes[1..]),
        Some(x) if &b'0' <= x && x <= &b'9' => (false, bytes),
        Some(x) => {
            return Err(ParseEndfRealError {
                kind: ParseEndfRealErrorKind::InvalidSign(char::from(*x)),
            })
        }
        None => {
            return Err(ParseEndfRealError {
                kind: ParseEndfRealErrorKind::Empty,
            })
        }
    };
    // extract integer part
    let (int_part, tail) = retrieve_digits(tail);
    if int_part.is_empty() {
        return Err(ParseEndfRealError {
            kind: ParseEndfRealErrorKind::EmptyIntegerPart,
        });
    }
    // expect decimal separator
    let tail = match tail.first() {
        Some(&b'.') => &tail[1..],
        Some(x) => {
            return Err(ParseEndfRealError {
                kind: ParseEndfRealErrorKind::InvalidDecimalSeparator(char::from(*x)),
            })
        }
        None => return Ok(parse_integer(neg, int_part)),
    };
    // extract fractional part
    let (frac_part, tail) = retrieve_digits(tail);
    if frac_part.is_empty() {
        return Err(ParseEndfRealError {
            kind: ParseEndfRealErrorKind::EmptyFractionalPart,
        });
    }
    // expect exponent separator
    let tail = match tail.first() {
        Some(&b'e') | Some(&b'E') => &tail[1..],
        Some(&b'-') | Some(&b'+') => tail,
        Some(x) => {
            return Err(ParseEndfRealError {
                kind: ParseEndfRealErrorKind::InvalidExponentSeparator(char::from(*x)),
            })
        }
        None => return Ok(parse_decimal(neg, int_part, frac_part)),
    };
    // extract exponent sign
    let (neg_exp, tail) = match tail.first() {
        Some(&b'-') => (true, &tail[1..]),
        Some(&b'+') => (false, &tail[1..]),
        Some(x) => {
            return Err(ParseEndfRealError {
                kind: ParseEndfRealErrorKind::InvalidExponentSign(char::from(*x)),
            })
        }
        None => {
            return Err(ParseEndfRealError {
                kind: ParseEndfRealErrorKind::EmptyExponentPart,
            })
        }
    };
    // extract exponent part
    let (exp_part, tail) = retrieve_digits(tail);
    if exp_part.is_empty() {
        return Err(ParseEndfRealError {
            kind: ParseEndfRealErrorKind::EmptyExponentPart,
        });
    }
    // expect empty tail
    if !tail.is_empty() {
        return Err(ParseEndfRealError {
            kind: ParseEndfRealErrorKind::Tail,
        });
    }
    Ok(parse_scientific(
        neg, int_part, frac_part, neg_exp, exp_part,
    ))
}

fn retrieve_digits(bytes: &[u8]) -> (&[u8], &[u8]) {
    let mut i = 0;
    while i < bytes.len() && b'0' <= bytes[i] && bytes[i] <= b'9' {
        i += 1
    }
    (&bytes[..i], &bytes[i..])
}

fn parse_integer(neg: bool, int_part: &[u8]) -> f64 {
    let number = parse_integer_unchecked(int_part) as f64;
    apply_sign(neg, number)
}

fn parse_decimal(neg: bool, int_part: &[u8], frac_part: &[u8]) -> f64 {
    let mantissa = parse_integer_unchecked(int_part.iter().chain(frac_part.iter())) as f64;
    let exp = -(frac_part.len() as i32);
    let number = mantissa * f64::from(ENDF_REAL_RADIX).powi(exp);
    apply_sign(neg, number)
}

fn parse_scientific(
    neg: bool,
    int_part: &[u8],
    frac_part: &[u8],
    neg_exp: bool,
    exp_part: &[u8],
) -> f64 {
    let mantissa = parse_integer_unchecked(int_part.iter().chain(frac_part.iter())) as f64;
    let mut exponent = parse_integer_unchecked(exp_part) as i32;
    exponent = apply_sign(neg_exp, exponent);
    exponent -= frac_part.len() as i32;
    let number = mantissa * 10_f64.powi(exponent);
    apply_sign(neg, number)
}

fn parse_integer_unchecked<'a, T>(bytes: T) -> u64
where
    T: IntoIterator<Item = &'a u8>,
{
    let mut result = 0;
    for &digit in bytes {
        result = result * 10 + (digit - b'0') as u64
    }
    result
}

fn apply_sign<T>(negative: bool, number: T) -> T
where
    T: std::ops::Neg<Output = T>,
{
    if negative {
        -number
    } else {
        number
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use regex::Regex;

    fn assert_endf_real_eq(expected: f64, actual: f64) {
        let mut exp = if expected.abs() <= 1. {
            0
        } else {
            expected.abs().log10().floor() as i32
        };
        exp -= ENDF_REAL_MAX_LEN as i32;
        let delta = 10_f64.powi(exp);
        let diff = (expected - actual).abs();
        if diff > delta {
            panic!(
                "assertion failed: (expected == actual)\n\
            expected = `{:?}\n\
            actual   = `{:?}\n\
            diff     = `{:?}`\n\
            delta    = `{:?}\n",
                expected, actual, diff, delta
            )
        }
    }

    #[test]
    fn parse_empty() {
        let real = "";
        let expected = ParseEndfRealErrorKind::Empty;
        let actual = parse(real).unwrap_err().kind();
        assert_eq!(expected, actual);
    }

    #[test]
    fn parse_whitespace() {
        // Rust allows following whitespace:
        // - ' ' (space)
        // - '\t' (tab)
        // - '\n' (line feed)
        // - '\r' (carriage return)
        let expected = ParseEndfRealErrorKind::Empty;
        assert_eq!(expected, parse(" ").unwrap_err().kind());
        assert_eq!(expected, parse("\t").unwrap_err().kind());
        assert_eq!(expected, parse("\n").unwrap_err().kind());
        assert_eq!(expected, parse("\r").unwrap_err().kind());
        assert_eq!(expected, parse(" \n\t\r").unwrap_err().kind());
    }

    #[test]
    fn parse_empty_exponent() {
        let expected = ParseEndfRealErrorKind::EmptyExponentPart;
        assert_eq!(expected, parse("1.2345e+").unwrap_err().kind());
        assert_eq!(expected, parse("1.2345e-").unwrap_err().kind());
        assert_eq!(expected, parse("1.2345+").unwrap_err().kind());
        assert_eq!(expected, parse("1.2345-").unwrap_err().kind());
    }

    #[test]
    fn parse_empty_fraction() {
        let expected = ParseEndfRealErrorKind::EmptyFractionalPart;
        assert_eq!(expected, parse(" 1.").unwrap_err().kind());
        assert_eq!(expected, parse("+1.").unwrap_err().kind());
        assert_eq!(expected, parse("-1.").unwrap_err().kind());
    }

    #[test]
    fn parse_empty_integer() {
        let expected = ParseEndfRealErrorKind::EmptyIntegerPart;
        assert_eq!(expected, parse("-.1").unwrap_err().kind());
        assert_eq!(expected, parse("+.1").unwrap_err().kind());
    }

    #[test]
    fn parse_sign_only() {
        let real = "-";
        let expected = ParseEndfRealErrorKind::EmptyIntegerPart;
        assert_eq!(expected, parse(real).unwrap_err().kind());
        let real = "+";
        assert_eq!(expected, parse(real).unwrap_err().kind());
    }

    #[test]
    fn parse_invalid() {
        let real = "1.2345e+6a";
        let expected = ParseEndfRealErrorKind::Tail;
        assert_eq!(expected, parse(real).unwrap_err().kind());
    }

    #[test]
    fn parse_invalid_decimal_separator() {
        let real = "-1,23456789";
        let expected = ParseEndfRealErrorKind::InvalidDecimalSeparator(',');
        assert_eq!(expected, parse(real).unwrap_err().kind());
        let real = "-1|23456789";
        let expected = ParseEndfRealErrorKind::InvalidDecimalSeparator('|');
        assert_eq!(expected, parse(real).unwrap_err().kind());
    }

    #[test]
    fn parse_invalid_exponent_separator() {
        let real = "-1.2345d+12";
        let expected = ParseEndfRealErrorKind::InvalidExponentSeparator('d');
        assert_eq!(expected, parse(real).unwrap_err().kind());
        let real = "-1.2345f+12";
        let expected = ParseEndfRealErrorKind::InvalidExponentSeparator('f');
        assert_eq!(expected, parse(real).unwrap_err().kind());
        let real = "-1.2345^+12";
        let expected = ParseEndfRealErrorKind::InvalidExponentSeparator('^');
        assert_eq!(expected, parse(real).unwrap_err().kind());
    }

    #[test]
    fn parse_invalid_sign() {
        let real = "a1.23456789";
        let expected = ParseEndfRealErrorKind::InvalidSign('a');
        assert_eq!(expected, parse(real).unwrap_err().kind());
        let real = "1.234567ea1";
        let expected = ParseEndfRealErrorKind::InvalidExponentSign('a');
        assert_eq!(expected, parse(real).unwrap_err().kind())
    }

    #[test]
    fn parse_non_ascii() {
        let real = "µ";
        let expected = ParseEndfRealErrorKind::NonAscii;
        assert_eq!(expected, parse(real).unwrap_err().kind());
    }

    #[test]
    fn parse_invalid_length() {
        let real = "+1.234567+12";
        let expected = ParseEndfRealErrorKind::TooLong;
        assert_eq!(expected, parse(real).unwrap_err().kind());
        let real = "+1.23456e+12";
        assert_eq!(expected, parse(real).unwrap_err().kind());
        let real = "+12345.67890";
        assert_eq!(expected, parse(real).unwrap_err().kind());
        let real = "-12345.67890";
        assert_eq!(expected, parse(real).unwrap_err().kind());
    }

    #[test]
    fn parse_valid_integer() {
        assert_endf_real_eq(1_234_567_890_f64, parse(" 1234567890").unwrap());
        assert_endf_real_eq(1_234_567_890_f64, parse("+1234567890").unwrap());
        assert_endf_real_eq(-1_234_567_890_f64, parse("-1234567890").unwrap());
    }

    #[test]
    fn parse_valid_real_max_precision() {
        assert_endf_real_eq(0., parse(" 0.00000000").unwrap());
        assert_endf_real_eq(0., parse("+0.00000000").unwrap());
        assert_endf_real_eq(0., parse("-0.00000000").unwrap());
        assert_endf_real_eq(1.234_567_89, parse(" 1.23456789").unwrap());
        assert_endf_real_eq(1.234_567_89, parse("+1.23456789").unwrap());
        assert_endf_real_eq(-1.234_567_89, parse("-1.23456789").unwrap());
    }

    #[test]
    fn parse_valid_real_eless_mid_precision() {
        assert_endf_real_eq(1.234_567e+1, parse(" 1.234567+1").unwrap());
        assert_endf_real_eq(1.234_567e+1, parse("+1.234567+1").unwrap());
        assert_endf_real_eq(-1.234_567e+1, parse("-1.234567+1").unwrap());
        assert_endf_real_eq(1.234_567e-1, parse(" 1.234567-1").unwrap());
        assert_endf_real_eq(1.234_567e-1, parse("+1.234567-1").unwrap());
        assert_endf_real_eq(-1.234_567e-1, parse("-1.234567-1").unwrap());
    }

    #[test]
    fn parse_valid_real_eless_min_precision() {
        assert_endf_real_eq(1.23456e+12, parse(" 1.23456+12").unwrap());
        assert_endf_real_eq(1.23456e+12, parse("+1.23456+12").unwrap());
        assert_endf_real_eq(-1.23456e+12, parse("-1.23456+12").unwrap());
        assert_endf_real_eq(1.23456e-12, parse(" 1.23456-12").unwrap());
        assert_endf_real_eq(1.23456e-12, parse("+1.23456-12").unwrap());
        assert_endf_real_eq(-1.23456e-12, parse("-1.23456-12").unwrap());
    }

    #[test]
    fn parse_valid_real_scientific_mid_precision() {
        assert_endf_real_eq(1.23456e+1, parse(" 1.23456e+1").unwrap());
        assert_endf_real_eq(1.23456e+1, parse("+1.23456e+1").unwrap());
        assert_endf_real_eq(-1.23456e+1, parse("-1.23456e+1").unwrap());
        assert_endf_real_eq(1.23456e+1, parse(" 1.23456E+1").unwrap());
        assert_endf_real_eq(1.23456e+1, parse("+1.23456E+1").unwrap());
        assert_endf_real_eq(-1.23456e+1, parse("-1.23456E+1").unwrap());
        assert_endf_real_eq(1.23456e-1, parse(" 1.23456e-1").unwrap());
        assert_endf_real_eq(1.23456e-1, parse("+1.23456e-1").unwrap());
        assert_endf_real_eq(-1.23456e-1, parse("-1.23456e-1").unwrap());
        assert_endf_real_eq(1.23456e-1, parse(" 1.23456E-1").unwrap());
        assert_endf_real_eq(1.23456e-1, parse("+1.23456E-1").unwrap());
        assert_endf_real_eq(-1.23456e-1, parse("-1.23456E-1").unwrap());
    }

    #[test]
    fn parse_valid_real_scientific_min_precision() {
        assert_endf_real_eq(1.2345e+12, parse(" 1.2345e+12").unwrap());
        assert_endf_real_eq(1.2345e+12, parse("+1.2345e+12").unwrap());
        assert_endf_real_eq(-1.2345e+12, parse("-1.2345e+12").unwrap());
        assert_endf_real_eq(1.2345e+12, parse(" 1.2345E+12").unwrap());
        assert_endf_real_eq(1.2345e+12, parse("+1.2345E+12").unwrap());
        assert_endf_real_eq(-1.2345e+12, parse("-1.2345E+12").unwrap());
        assert_endf_real_eq(1.2345e-12, parse(" 1.2345e-12").unwrap());
        assert_endf_real_eq(1.2345e-12, parse("+1.2345e-12").unwrap());
        assert_endf_real_eq(-1.2345e-12, parse("-1.2345e-12").unwrap());
        assert_endf_real_eq(1.2345e-12, parse(" 1.2345E-12").unwrap());
        assert_endf_real_eq(1.2345e-12, parse("+1.2345E-12").unwrap());
        assert_endf_real_eq(-1.2345e-12, parse("-1.2345E-12").unwrap());
    }

    #[test]
    fn regex_integer() {
        let regex = Regex::new(ENDF_REAL_REGEX).unwrap();
        assert!(regex.is_match("1"));
        assert!(regex.is_match("+1"));
        assert!(regex.is_match("-1"));
        assert!(regex.is_match(" 1234567890"));
        assert!(regex.is_match("-1234567890"));
        assert!(regex.is_match("+1234567890"));
        assert!(regex.is_match("          1"));
        assert!(regex.is_match("         +1"));
        assert!(regex.is_match("         -1"));
    }

    #[test]
    fn regex_decimal() {
        let regex = Regex::new(ENDF_REAL_REGEX).unwrap();
        assert!(regex.is_match("-1.23456789"));
        assert!(regex.is_match("+1.23456789"));
        assert!(regex.is_match(" 1.23456789"));
    }

    #[test]
    fn regex_scientific() {
        let regex = Regex::new(ENDF_REAL_REGEX).unwrap();
        assert!(regex.is_match(" +1.2345e+1"));
        assert!(regex.is_match(" +1.2345E+1"));
        assert!(regex.is_match(" -1.2345e+1"));
        assert!(regex.is_match("  1.2345e+1"));
        assert!(regex.is_match(" +1.2345e-1"));
        assert!(regex.is_match(" -1.2345e-1"));
        assert!(regex.is_match("  1.2345e-1"));
        assert!(regex.is_match("   1.2345-1"));
        assert!(regex.is_match("  -1.2345-1"));
        assert!(regex.is_match("  +1.2345-1"));
        assert!(regex.is_match(" +1.2345-12"));
        assert!(regex.is_match(" -1.2345-12"));
        assert!(regex.is_match("  1.2345-12"));
    }

    #[test]
    fn regex_invalid() {
        let regex = Regex::new(ENDF_REAL_REGEX).unwrap();
        assert!(!regex.is_match(""));
        assert!(!regex.is_match(" "));
        assert!(!regex.is_match("."));
        assert!(!regex.is_match("e"));
        assert!(!regex.is_match("E"));
        assert!(!regex.is_match("0."));
        assert!(!regex.is_match("1."));
        assert!(!regex.is_match("-1."));
        assert!(!regex.is_match("+1."));
        assert!(!regex.is_match("1e1"));
        assert!(!regex.is_match("1e"));
    }
}