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::greedy_string;
use ::iosonism::args::integer;
use ::iosonism::args::string;
use ::iosonism::args::word;
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);
        }
    }
}

#[test]
fn test_string__parse__word() {
    let mut reader = Cursor::new("hello");
    assert_eq!(
        ArgumentType::<(), ErrorPanic>::parse(&word(), &mut reader),
        Ok("hello".into()),
    );
}

#[test]
fn test_string__parse__string() {
    let mut reader = Cursor::new("\"hello world\"");
    assert_eq!(
        ArgumentType::<(), ErrorPanic>::parse(&string(), &mut reader),
        Ok("hello world".into()),
    );
}

#[test]
fn test_string__parse__greedy_string() {
    let mut reader = Cursor::new("Hello world! This is a test.");
    assert_eq!(
        ArgumentType::<(), ErrorPanic>::parse(&greedy_string(), &mut reader),
        Ok("Hello world! This is a test.".into()),
    );
    assert!(!reader.can_read());
}