use std::cmp::Ordering;
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use validatable::{Format::*, Message::*, *};
use super::util::*;
macro_rules! validate_string_eq {
($i: expr, $e: expr) => {
let r: Result<T, Message> = ValidatedValue::from_input(&$i.to_owned());
assert_eq!(r.map(|v| v.into_raw()), $e);
};
($i: expr, $e1: expr, $e2: expr) => {
let r: Result<T, Message> = ValidatedValue::from_input(&$i.to_owned());
let r = r.map(|v| v.into_raw());
if !(r == $e1 || r == $e2) {
assert_eq!(r, $e1);
assert_eq!(r, $e2);
}
};
}
#[test]
fn logic() {
{
type T = Validated<String, Or<LengthMin<5>, LengthMax<2>>>;
validate_string_eq!("", Ok(s!("")));
validate_string_eq!("a", Ok(s!("a")));
validate_string_eq!("aa", Ok(s!("aa")));
validate_string_eq!("aaa", Err(LengthExceedMin(s!("5"))));
validate_string_eq!("aaaa", Err(LengthExceedMin(s!("5"))));
validate_string_eq!("aaaaa", Ok(s!("aaaaa")));
}
{
type T = Validated<String, Or<LengthMax<2>, LengthMin<5>>>;
validate_string_eq!("", Ok(s!("")));
validate_string_eq!("a", Ok(s!("a")));
validate_string_eq!("aa", Ok(s!("aa")));
validate_string_eq!("aaa", Err(LengthExceedMax(s!("2"))));
validate_string_eq!("aaaa", Err(LengthExceedMax(s!("2"))));
validate_string_eq!("aaaaa", Ok(s!("aaaaa")));
}
{
type T = Validated<String, Chain<Trim, Or<LengthMax<2>, LengthMin<5>>>>;
validate_string_eq!(" ", Ok(s!("")));
validate_string_eq!(" a", Ok(s!("a")));
validate_string_eq!(" aa", Ok(s!("aa")));
validate_string_eq!(" aaa", Err(LengthExceedMax(s!("2"))));
validate_string_eq!(" aaaa", Err(LengthExceedMax(s!("2"))));
validate_string_eq!(" aaaaa", Ok(s!("aaaaa")));
}
{
type T = Validated<String, Chain<Or<LengthMax<2>, LengthMin<5>>, Trim>>;
validate_string_eq!(" ", Ok(s!("")));
validate_string_eq!(" a", Ok(s!("a")));
validate_string_eq!(" aa", Err(LengthExceedMax(s!("2"))));
validate_string_eq!(" aaa", Err(LengthExceedMax(s!("2"))));
validate_string_eq!(" aaaa", Ok(s!("aaaa")));
validate_string_eq!(" aaaaa", Ok(s!("aaaaa")));
}
{
type T = Validated<String, And<LengthMin<1>, LengthMax<5>>>;
validate_string_eq!("", Err(Empty));
validate_string_eq!("a", Ok(s!("a")));
validate_string_eq!("aaaaa", Ok(s!("aaaaa")));
validate_string_eq!("aaaaaa", Err(LengthExceedMax(s!("5"))));
}
{
type T = Validated<String, Not<LengthMin<3>>>;
validate_string_eq!("", Ok(s!("")));
validate_string_eq!("aa", Ok(s!("aa")));
validate_string_eq!("aaa", Err(ContentProblem));
}
{
type T = Validated<String, Or<Trim, True>>;
validate_string_eq!(" a ", Ok(s!("a")));
}
}
#[test]
fn from_input_owned() {
{
type T = Validated<String, Chain<Trim, LengthRange<1, 8>>>;
let v: T = ValidatedValue::from_input_owned(s!(" Ada ")).unwrap();
assert_eq!(v.into_raw(), s!("Ada"));
let r: Result<T, Message> = ValidatedValue::from_input_owned(s!(" "));
assert_eq!(r.map(|v| v.into_raw()), Err(Empty));
}
{
struct NotClone(String);
impl Parsable<NotClone> for String {
fn parse(i: NotClone) -> Result<Self, Message> {
Ok(i.0)
}
}
type T = ValidatedValue<String, NotClone, True, LengthMax<3>>;
let v: T = ValidatedValue::from_input_owned(NotClone(s!("abc"))).unwrap();
assert_eq!(v.into_raw(), s!("abc"));
}
}
#[test]
fn or_clone_count() {
use std::cell::Cell;
use std::rc::Rc;
struct Counted(Rc<Cell<usize>>);
impl Clone for Counted {
fn clone(&self) -> Self {
self.0.set(self.0.get() + 1);
Counted(Rc::clone(&self.0))
}
}
let count = Rc::new(Cell::new(0));
assert!(<Or<True, True> as Validator<Counted>>::validate(Counted(Rc::clone(&count))).is_ok());
assert_eq!(count.get(), 1);
let count = Rc::new(Cell::new(0));
assert!(<Or<False, True> as Validator<Counted>>::validate(Counted(Rc::clone(&count))).is_ok());
assert_eq!(count.get(), 2);
}
#[test]
fn integer() {
macro_rules! signed_integer_test {
($t: ty) => {{
type T = Validated<$t, True, SignedValueMin<-10>>;
validate_string_eq!("-11", Err(ValueExceedMin(s!("-10"))));
validate_string_eq!("-10", Ok(-10));
validate_string_eq!("0", Ok(0));
validate_string_eq!("-0", Ok(0));
validate_string_eq!("5", Ok(5));
}
{
type T = Validated<$t, True, SignedValueMax<-10>>;
validate_string_eq!("-10", Ok(-10));
validate_string_eq!("9", Err(ValueExceedMax(s!("-10"))));
validate_string_eq!("0", Err(ValueExceedMax(s!("-10"))));
validate_string_eq!("5", Err(ValueExceedMax(s!("-10"))));
}};
}
signed_integer_test!(i8);
signed_integer_test!(i16);
signed_integer_test!(i32);
signed_integer_test!(i64);
macro_rules! unsigned_integer_test {
($t: ty) => {{
type T = Validated<$t, True, UnsignedValueMin<10>>;
validate_string_eq!("-11", Err(ValueExceedMin(s!("0"))));
validate_string_eq!("0", Err(ValueExceedMin(s!("10"))));
validate_string_eq!("-0", Err(ValueExceedMin(s!("10"))));
validate_string_eq!("5", Err(ValueExceedMin(s!("10"))));
validate_string_eq!("10", Ok(10));
validate_string_eq!("11", Ok(11));
}
{
type T = Validated<$t, True, UnsignedValueMax<10>>;
validate_string_eq!("-11", Err(ValueExceedMin(s!("0"))));
validate_string_eq!("0", Ok(0));
validate_string_eq!("-0", Ok(0));
validate_string_eq!("5", Ok(5));
validate_string_eq!("10", Ok(10));
validate_string_eq!("11", Err(ValueExceedMax(s!("10"))));
}};
}
unsigned_integer_test!(u8);
unsigned_integer_test!(u16);
unsigned_integer_test!(u32);
unsigned_integer_test!(u64);
macro_rules! signed_with_unsigned_validator_test {
($t: ty) => {{
type T = Validated<$t, True, UnsignedValueMax<10>>;
validate_string_eq!("-11", Err(ValueExceedMin(s!("0"))));
validate_string_eq!("-1", Err(ValueExceedMin(s!("0"))));
validate_string_eq!("0", Ok(0));
validate_string_eq!("-0", Ok(0));
validate_string_eq!("10", Ok(10));
validate_string_eq!("11", Err(ValueExceedMax(s!("10"))));
}};
}
signed_with_unsigned_validator_test!(i8);
signed_with_unsigned_validator_test!(i16);
signed_with_unsigned_validator_test!(i32);
signed_with_unsigned_validator_test!(i64);
macro_rules! parse_test {
($t: ty) => {{
type T = Validated<$t, True>;
validate_string_eq!("0", Ok(0));
validate_string_eq!("-0", Ok(0));
validate_string_eq!("123", Ok(123));
validate_string_eq!("", Err(Empty));
validate_string_eq!(
"a",
Err(BadFormat(SignedInteger)),
Err(BadFormat(UnsignedInteger))
);
validate_string_eq!(" 123 ", Ok(123));
validate_string_eq!("\n\t 45 ", Ok(45));
validate_string_eq!(" ", Err(Empty));
validate_string_eq!(
" 1 2 ",
Err(BadFormat(SignedInteger)),
Err(BadFormat(UnsignedInteger))
);
validate_string_eq!(
format!("{}9", <$t>::MAX),
Err(ValueExceedMax(<$t>::MAX.to_string()))
);
validate_string_eq!(
"-99999999999999999999999999999999999999",
Err(ValueExceedMin(<$t>::MIN.to_string()))
);
}
{
type T = Validated<$t, Trim>;
validate_string_eq!("0", Ok(0));
validate_string_eq!(" -0 ", Ok(0));
validate_string_eq!("123", Ok(123));
validate_string_eq!("", Err(Empty));
validate_string_eq!(
"a",
Err(BadFormat(SignedInteger)),
Err(BadFormat(UnsignedInteger))
);
validate_string_eq!(" 123 ", Ok(123));
validate_string_eq!("\n\t 45 ", Ok(45));
}};
}
parse_test!(i8);
parse_test!(i16);
parse_test!(i32);
parse_test!(i64);
parse_test!(u8);
parse_test!(u16);
parse_test!(u32);
parse_test!(u64);
}
#[test]
fn float() {
macro_rules! float_test {
($t: ty) => {{
type T = Validated<$t, True, FloatValueMinX1000<1_500>>;
validate_string_eq!("-1", Err(ValueExceedMin(s!("1.5"))));
validate_string_eq!("0.0", Err(ValueExceedMin(s!("1.5"))));
validate_string_eq!("1.50", Ok(1.5));
validate_string_eq!("1.6", Ok(1.6));
}
{
type T = Validated<$t, True, FloatValueMaxX1000<1_500>>;
validate_string_eq!("-1", Ok(-1.0));
validate_string_eq!("0.0", Ok(0.0));
validate_string_eq!("1.50", Ok(1.5));
validate_string_eq!("1.6", Err(ValueExceedMax(s!("1.5"))));
}
{
type T = Validated<$t, True, FloatValueMaxX1000<100>>;
assert_eq!(T::from_raw(0.1).map(|v| v.into_raw()), Ok(0.1));
validate_string_eq!("0.1", Ok(0.1));
validate_string_eq!("0.11", Err(ValueExceedMax(s!("0.1"))));
}
{
type T = Validated<$t, True, FloatValueMinX1000<100>>;
assert_eq!(T::from_raw(0.1).map(|v| v.into_raw()), Ok(0.1));
validate_string_eq!("0.1", Ok(0.1));
validate_string_eq!("0.09", Err(ValueExceedMin(s!("0.1"))));
}
{
type T = Validated<$t, True>;
validate_string_eq!("NaN", Err(BadFormat(Float)));
validate_string_eq!("nan", Err(BadFormat(Float)));
validate_string_eq!("inf", Err(ValueExceedMax(<$t>::MAX.to_string())));
validate_string_eq!("-inf", Err(ValueExceedMin(<$t>::MIN.to_string())));
validate_string_eq!("infinity", Err(ValueExceedMax(<$t>::MAX.to_string())));
validate_string_eq!("1e999", Err(ValueExceedMax(<$t>::MAX.to_string())));
validate_string_eq!("-1e999", Err(ValueExceedMin(<$t>::MIN.to_string())));
validate_string_eq!("1.5", Ok(1.5));
validate_string_eq!(" 1.5\t ", Ok(1.5));
validate_string_eq!(" ", Err(Empty));
}
{
type T = Validated<$t, True, FloatValueRangeX1000<0, 100_000>>;
assert_eq!(
T::from_raw(<$t>::NAN).map(|v| v.into_raw()),
Err(BadFormat(Float))
);
assert_eq!(
T::from_raw(<$t>::INFINITY).map(|v| v.into_raw()),
Err(ValueExceedMax(s!("100")))
);
assert_eq!(
T::from_raw(<$t>::NEG_INFINITY).map(|v| v.into_raw()),
Err(ValueExceedMin(s!("0")))
);
validate_string_eq!("NaN", Err(BadFormat(Float)));
}
{
type TMin = Validated<$t, True, FloatValueMinX1000<0>>;
assert_eq!(
TMin::from_raw(<$t>::INFINITY).map(|v| v.into_raw()),
Ok(<$t>::INFINITY)
);
type TMax = Validated<$t, True, FloatValueMaxX1000<0>>;
assert_eq!(
TMax::from_raw(<$t>::NEG_INFINITY).map(|v| v.into_raw()),
Ok(<$t>::NEG_INFINITY)
);
}
{
type T = Validated<$t, True, FloatValueMinX1000<16_777_219>>;
assert!(T::from_raw(16777.219).is_ok());
}};
}
float_test!(f32);
float_test!(f64);
}
#[test]
fn string() {
{
type T = Validated<String, LengthMin<3>>;
validate_string_eq!("", Err(Empty));
validate_string_eq!("a", Err(LengthExceedMin(s!("3"))));
validate_string_eq!("abc", Ok(s!("abc")));
validate_string_eq!("abcd", Ok(s!("abcd")));
}
{
type T = Validated<String, LengthMax<3>>;
validate_string_eq!("", Ok(s!("")));
validate_string_eq!("a", Ok(s!("a")));
validate_string_eq!("abc", Ok(s!("abc")));
validate_string_eq!("abcd", Err(LengthExceedMax(s!("3"))));
}
{
type T = Validated<String, LengthRange<1, 3>>;
validate_string_eq!("", Err(Empty));
validate_string_eq!("a", Ok(s!("a")));
validate_string_eq!("abc", Ok(s!("abc")));
validate_string_eq!("abcd", Err(LengthExceedMax(s!("3"))));
}
{
type T = Validated<String, LengthRange<0, 3>>;
validate_string_eq!("", Ok(s!("")));
validate_string_eq!("a", Ok(s!("a")));
validate_string_eq!("abc", Ok(s!("abc")));
validate_string_eq!("abcd", Err(LengthExceedMax(s!("3"))));
}
{
type T = Validated<String, LengthMax<3>>;
let v: T = ValidatedValue::from_input(&s!("abc")).unwrap();
assert_eq!(v.len(), 3);
assert_eq!(v.chars().next(), Some('a'));
}
}
#[test]
fn string_char_class() {
{
type T = Validated<String, AllChars<CharClassAscii>>;
validate_string_eq!("", Ok(s!("")));
validate_string_eq!("a", Ok(s!("a")));
validate_string_eq!("aあb, ", Err(InvalidChars(cs!(" あ"))));
}
{
type T = Validated<
String,
AllChars<Or<CharClassAsciiPunctuation, CharClassDigit, CharClassLowercase>>,
>;
validate_string_eq!("", Ok(s!("")));
validate_string_eq!("ABCa123", Err(InvalidChars(cs!("ABC"))));
validate_string_eq!("-!a123", Ok(s!("-!a123")));
}
{
type T = Validated<String, AllChars<And<CharClassAsciiHexdigit, CharClassAsciiUppercase>>>;
validate_string_eq!("", Ok(s!("")));
validate_string_eq!("ABC123", Err(InvalidChars(cs!("123"))));
validate_string_eq!("ffAAZ", Err(InvalidChars(cs!("Zf"))));
validate_string_eq!("ABFF", Ok(s!("ABFF")));
}
{
type T = Validated<String, Chain<Trim, AllChars<CharClassJust<'J'>>>>;
validate_string_eq!("", Ok(s!("")));
validate_string_eq!(" JJJ ", Ok(s!("JJJ")));
validate_string_eq!("AJJA", Err(InvalidChars(cs!("A"))));
}
{
type T = Validated<String, Chain<Trim, AllChars<Not<CharClassJust<'J'>>>>>;
validate_string_eq!("", Ok(s!("")));
validate_string_eq!(" JJJ ", Err(InvalidChars(cs!("J"))));
validate_string_eq!(" a b c ", Ok(s!("a b c")));
}
{
type T = Validated<String, RemoveChars<CharClassWhitespace>>;
validate_string_eq!("", Ok(s!("")));
validate_string_eq!(" A J Cc ", Ok(s!("AJCc")));
validate_string_eq!("abc ", Ok(s!("abc")));
}
{
type T = Validated<String, AllChars<CharClassAsciiDigit>>;
validate_string_eq!(
"0123456789abcdefghijklmnopqrstuvwxyz",
Err(InvalidChars(cs!("abcdefghij")))
);
}
}
#[test]
fn non_empty_string() {
{
type T = Validated<NonEmptyString, AllChars<CharClassAsciiDigit>>;
validate_string_eq!("123", Ok(ns!("123")));
validate_string_eq!("", Err(Empty));
validate_string_eq!("12a", Err(InvalidChars(cs!("a"))));
}
{
type T = Validated<NonEmptyString, Chain<Trim, AllChars<CharClassAsciiAlphabetic>>>;
validate_string_eq!(" abc ", Ok(ns!("abc")));
validate_string_eq!(" ", Err(Empty));
}
{
type T = Validated<NonEmptyString, Trim>;
let v: T = ValidatedValue::from_input(&s!(" x ")).unwrap();
assert_eq!(NonEmptyString::from(v.clone()), ns!("x"));
assert_eq!(<T as ValidatableValue<String>>::into_input(v), s!("x"));
}
#[cfg(feature = "serde")]
{
type T = Validated<NonEmptyString, AllChars<CharClassAsciiDigit>>;
let v: T = ValidatedValue::from_input(&s!("123")).unwrap();
assert_eq!(serde_json::to_string(&v).unwrap(), r#""123""#);
assert_eq!(serde_json::from_str::<T>(r#""123""#).unwrap(), v);
assert!(serde_json::from_str::<T>(r#""""#).is_err());
}
}
#[test]
fn implementations() {
macro_rules! from_test {
($t: ty, $r: expr, $d: expr) => {{
type T = Validated<$t, True, True>;
let r: $t = $r;
let v: T = T::from_raw(r.clone()).unwrap();
let d: T = T::from_raw($d).unwrap();
assert_eq!(<$t as From<T>>::from(v.clone()), r);
assert_eq!(v.as_ref(), &r);
assert_eq!(&*v, &r);
assert_eq!(v, v);
assert_ne!(v, d);
assert_eq!(v.partial_cmp(&v), Some(Ordering::Equal));
assert_eq!(v.partial_cmp(&d), Some(Ordering::Less));
assert_eq!(v.cmp(&v), Ordering::Equal);
assert_eq!(v.cmp(&d), Ordering::Less);
assert_eq!(calculate_hash(&v), calculate_hash(&v));
assert_ne!(calculate_hash(&v), calculate_hash(&d));
}};
}
fn calculate_hash<T: Hash>(t: &T) -> u64 {
let mut s = DefaultHasher::new();
t.hash(&mut s);
s.finish()
}
from_test!(i8, 123, 124);
from_test!(i16, 234, 235);
from_test!(i32, -10, -9);
from_test!(i64, -20, 21);
from_test!(u8, 0x5, 0x6);
from_test!(u16, 1_000, 1_001);
from_test!(u32, 123, 124);
from_test!(u64, 123, 124);
from_test!(String, s!("あいう"), s!("あいうえ"));
from_test!(bool, false, true);
}
#[test]
fn fmt() {
macro_rules! fmt_test {
($t: ty, $v: expr) => {{
type T = Validated<$t, True, True>;
let r = $v;
let v: T = T::from_raw($v).unwrap();
assert_eq!(format!("{} {:?}", v, v), format!("{} {:?}", r, r));
}};
}
fmt_test!(i8, 123);
fmt_test!(i16, 234);
fmt_test!(i32, -10);
fmt_test!(i64, -20);
fmt_test!(u8, 0x5);
fmt_test!(u16, 1_000);
fmt_test!(u32, 123);
fmt_test!(u64, 123);
fmt_test!(String, s!("あいう"));
fmt_test!(bool, true);
}
#[test]
#[cfg(feature = "serde")]
fn serde() {
let b: Validated<String, True, LengthRange<2, 10>> = vs!("fooあいうえ");
assert_eq!(serde_json::to_string(&b).unwrap(), r#""fooあいうえ""#);
assert_eq!(
serde_json::from_str::<Validated<String, True, LengthRange<2, 10>>>(r#""fooあいうえ""#)
.unwrap(),
b
);
assert!(serde_json::from_str::<Validated<String, True, LengthRange<2, 10>>>(r#""f""#).is_ok()); assert!(serde_json::from_str::<Validated<String, True, LengthRange<2, 10>>>(r#"aaa"#).is_err());
}