path: root/tests/arguments.rs

// Copyright (c) 2021 Soni L.
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.
// Documentation and comments licensed under CC BY-SA 4.0.

// because we wanna use double underscore (__) for test names
#![allow(non_snake_case)]

use ::std::io::Cursor;

use ::iosonism::args::ArgumentType;
use ::iosonism::args::BoolArgumentType;
use ::iosonism::args::bounded_float;
use ::iosonism::args::bounded_integer;
use ::iosonism::args::float;
use ::iosonism::args::integer;
use ::iosonism::strcursor::StringReader;

mod common;

use self::common::ErrorCall;
use self::common::ErrorFunc;
use self::common::ErrorPanic;
use self::common::ErrorType;

#[test]
fn test_bool__parse() {
    assert_eq!(
        ArgumentType::<(), ErrorPanic>::parse(
            &BoolArgumentType,
            &mut Cursor::new("true"),
        ),
        Ok(true),
    );
    assert_eq!(
        ArgumentType::<(), ErrorPanic>::parse(
            &BoolArgumentType,
            &mut Cursor::new("false"),
        ),
        Ok(false),
    );
}

#[test]
fn test_i32__parse() {
    let mut reader = Cursor::new("15");
    assert_eq!(
        ArgumentType::<(), ErrorPanic>::parse(
            &integer::<i32>(),
            &mut reader,
        ),
        Ok(15),
    );
    assert!(!reader.can_read());
}

#[test]
fn test_i32__parse__range() {
    let mut reader = Cursor::new("-5");
    assert!(ArgumentType::<(), ErrorCall<ErrFn>>::parse(
        &bounded_integer(0..100i32),
        &mut reader,
    ).is_err());
    struct ErrFn;
    impl<'a> ErrorFunc<'a, Cursor<&'a str>> for ErrFn {
        fn call(context: &Cursor<&'a str>, ty: ErrorType) {
            assert!(matches!(ty, ErrorType::RangeErrori32(..)));
            assert_eq!(context.position(), 0);
        }
    }
}

#[test]
fn test_i64__parse() {
    let mut reader = Cursor::new("15");
    assert_eq!(
        ArgumentType::<(), ErrorPanic>::parse(
            &integer::<i64>(),
            &mut reader,
        ),
        Ok(15),
    );
    assert!(!reader.can_read());
}

#[test]
fn test_i64__parse__range() {
    let mut reader = Cursor::new("-5");
    assert!(ArgumentType::<(), ErrorCall<ErrFn>>::parse(
        &bounded_integer(0..100i64),
        &mut reader,
    ).is_err());
    struct ErrFn;
    impl<'a> ErrorFunc<'a, Cursor<&'a str>> for ErrFn {
        fn call(context: &Cursor<&'a str>, ty: ErrorType) {
            assert!(matches!(ty, ErrorType::RangeErrori64(..)));
            assert_eq!(context.position(), 0);
        }
    }
}

#[test]
fn test_f32__parse() {
    let mut reader = Cursor::new("15");
    assert_eq!(
        ArgumentType::<(), ErrorPanic>::parse(
            &float::<f32>(),
            &mut reader,
        ),
        Ok(15.0),
    );
    assert!(!reader.can_read());
}

#[test]
fn test_f32__parse__range() {
    let mut reader = Cursor::new("-5");
    assert!(ArgumentType::<(), ErrorCall<ErrFn>>::parse(
        &bounded_float(0.0..100f32),
        &mut reader,
    ).is_err());
    struct ErrFn;
    impl<'a> ErrorFunc<'a, Cursor<&'a str>> for ErrFn {
        fn call(context: &Cursor<&'a str>, ty: ErrorType) {
            assert!(matches!(ty, ErrorType::RangeErrorf32(..)));
            assert_eq!(context.position(), 0);
        }
    }
}

#[test]
fn test_f64__parse() {
    let mut reader = Cursor::new("15");
    assert_eq!(
        ArgumentType::<(), ErrorPanic>::parse(
            &float::<f64>(),
            &mut reader,
        ),
        Ok(15.0),
    );
    assert!(!reader.can_read());
}

#[test]
fn test_f64__parse__range() {
    let mut reader = Cursor::new("-5");
    assert!(ArgumentType::<(), ErrorCall<ErrFn>>::parse(
        &bounded_float(0.0..100f64),
        &mut reader,
    ).is_err());
    struct ErrFn;
    impl<'a> ErrorFunc<'a, Cursor<&'a str>> for ErrFn {
        fn call(context: &Cursor<&'a str>, ty: ErrorType) {
            assert!(matches!(ty, ErrorType::RangeErrorf64(..)));
            assert_eq!(context.position(), 0);
        }
    }
}