From 36395c7437218b86c832cc041f7a58f325a007bb Mon Sep 17 00:00:00 2001
From: SoniEx2 <endermoneymod@gmail.com>
Date: Sat, 4 Dec 2021 17:46:00 -0300
Subject: Add integer and float arguments

---
 tests/arguments.rs | 158 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 158 insertions(+)
 create mode 100644 tests/arguments.rs

(limited to 'tests/arguments.rs')

diff --git a/tests/arguments.rs b/tests/arguments.rs
new file mode 100644
index 0000000..4b5a2a0
--- /dev/null
+++ b/tests/arguments.rs
@@ -0,0 +1,158 @@
+// 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 ::std::marker::PhantomData;
+
+use ::iosonism::args::ArgumentType;
+use ::iosonism::args::BoolArgumentType;
+use ::iosonism::args::FloatArgumentType;
+use ::iosonism::args::IntegerArgumentType;
+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(
+            &IntegerArgumentType { range: .., _ty: PhantomData::<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(
+        &IntegerArgumentType { range: 0..=100, _ty: PhantomData::<i32> },
+        &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(
+            &IntegerArgumentType { range: .., _ty: PhantomData::<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(
+        &IntegerArgumentType { range: 0..=100, _ty: PhantomData::<i64> },
+        &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(
+            &FloatArgumentType { range: .., _ty: PhantomData::<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(
+        &FloatArgumentType { range: 0.0..=100.0, _ty: PhantomData::<f32> },
+        &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(
+            &FloatArgumentType { range: .., _ty: PhantomData::<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(
+        &FloatArgumentType { range: 0.0..=100.0, _ty: PhantomData::<f64> },
+        &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);
+        }
+    }
+}
+
-- 
cgit 1.4.1