PATH=C:\mingw\bin;C:\cygwin\bin;C:\cpanfly-5.18\var\megalib\bin;C:\Perl64-5.18\site\bin;C:\Perl64-5.18\bin;C:\cygwin\bin;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\system32\WindowsPowerShell\v1.0;C:\PROGRA~2\Perforce;C:\instantclient_11_2;C:\cygwin\bin;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\system32\WindowsPowerShell\v1.0;C:\PROGRA~2\Perforce;C:\mysql\bin
Start 2014-04-16T13:33:49
ActivePerl-1800 CPAN-2.00
PATH=C:/CPANFL~1.18/var/libs/bin;C:\mingw\bin;C:\cygwin\bin;C:\CPANFL~1.18\var\megalib\bin;C:\Perl64-5.18\site\bin;C:\Perl64-5.18\bin;C:\cygwin\bin;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\system32\WINDOW~1\v1.0;C:\PROGRA~2\Perforce;C:\INSTAN~1;C:\cygwin\bin;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\system32\WINDOW~1\v1.0;C:\PROGRA~2\Perforce;C:\mysql\bin
Reading 'C:\cpanfly-5.18\var\cpan\Metadata'
Database was generated on Wed, 16 Apr 2014 18:41:02 GMT
Running make for S/SH/SHARYANTO/Perinci-Sub-GetArgs-Argv-0.34.tar.gz
Checksum for C:\cpanfly-5.18\var\cpan\sources\authors\id\S\SH\SHARYANTO\Perinci-Sub-GetArgs-Argv-0.34.tar.gz ok
Perinci-Sub-GetArgs-Argv-0.34/
Perinci-Sub-GetArgs-Argv-0.34/README
Perinci-Sub-GetArgs-Argv-0.34/lib/
Perinci-Sub-GetArgs-Argv-0.34/lib/Perinci/
Perinci-Sub-GetArgs-Argv-0.34/lib/Perinci/Sub/
Perinci-Sub-GetArgs-Argv-0.34/lib/Perinci/Sub/GetArgs/
Perinci-Sub-GetArgs-Argv-0.34/lib/Perinci/Sub/GetArgs/Argv.pm
Perinci-Sub-GetArgs-Argv-0.34/Makefile.PL
Perinci-Sub-GetArgs-Argv-0.34/Changes
Perinci-Sub-GetArgs-Argv-0.34/dist.ini
Perinci-Sub-GetArgs-Argv-0.34/LICENSE
Perinci-Sub-GetArgs-Argv-0.34/t/
Perinci-Sub-GetArgs-Argv-0.34/t/00-compile.t
Perinci-Sub-GetArgs-Argv-0.34/t/01-basics.t
Perinci-Sub-GetArgs-Argv-0.34/t/release-pod-coverage.t
Perinci-Sub-GetArgs-Argv-0.34/t/release-pod-syntax.t
Perinci-Sub-GetArgs-Argv-0.34/t/release-rinci.t
Perinci-Sub-GetArgs-Argv-0.34/weaver.ini
Perinci-Sub-GetArgs-Argv-0.34/MANIFEST
Perinci-Sub-GetArgs-Argv-0.34/META.json
Perinci-Sub-GetArgs-Argv-0.34/META.yml
CPAN.pm: Building S/SH/SHARYANTO/Perinci-Sub-GetArgs-Argv-0.34.tar.gz
>>> C:\Perl64-5.18\bin\perl.exe Makefile.PL
Warning: prerequisite Data::Sah 0.02 not found.
Warning: prerequisite Perinci::Sub::GetArgs::Array 0.11 not found.
Warning: prerequisite YAML::Syck 0 not found.
Checking if your kit is complete...
Looks good
Generating a dmake-style Makefile
Writing Makefile for Perinci::Sub::GetArgs::Argv
Writing MYMETA.yml and MYMETA.json
---- Unsatisfied dependencies detected during ----
---- SHARYANTO/Perinci-Sub-GetArgs-Argv-0.34.tar.gz ----
Data::Sah [requires]
Perinci::Sub::GetArgs::Array [requires]
YAML::Syck [requires]
Running make test
Delayed until after prerequisites
Running test for module 'Data::Sah'
Running make for S/SH/SHARYANTO/Data-Sah-0.22.tar.gz
Checksum for C:\cpanfly-5.18\var\cpan\sources\authors\id\S\SH\SHARYANTO\Data-Sah-0.22.tar.gz ok
Data-Sah-0.22/
Data-Sah-0.22/devscripts/
Data-Sah-0.22/devscripts/list-missing-translations
Data-Sah-0.22/Changes
Data-Sah-0.22/LICENSE
Data-Sah-0.22/MANIFEST
Data-Sah-0.22/lib/
Data-Sah-0.22/lib/Data/
Data-Sah-0.22/lib/Data/Sah.pm
Data-Sah-0.22/lib/Data/Sah/
Data-Sah-0.22/lib/Data/Sah/Schema/
Data-Sah-0.22/lib/Data/Sah/Schema/Common.pm
Data-Sah-0.22/lib/Data/Sah/Schema/sah.pm
Data-Sah-0.22/lib/Data/Sah/Util/
Data-Sah-0.22/lib/Data/Sah/Util/Func.pm
Data-Sah-0.22/lib/Data/Sah/Util/TypeX.pm
Data-Sah-0.22/lib/Data/Sah/Util/Role.pm
Data-Sah-0.22/lib/Data/Sah/JS.pm
Data-Sah-0.22/lib/Data/Sah/Lang/
Data-Sah-0.22/lib/Data/Sah/Lang/fr_FR.pm
Data-Sah-0.22/lib/Data/Sah/Lang/zh_CN.pm
Data-Sah-0.22/lib/Data/Sah/Lang/id_ID.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/
Data-Sah-0.22/lib/Data/Sah/Compiler/Prog/
Data-Sah-0.22/lib/Data/Sah/Compiler/Prog/TH/
Data-Sah-0.22/lib/Data/Sah/Compiler/Prog/TH/all.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/Prog/TH/any.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/Prog/TH.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/TextResultRole.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/undef.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/hash.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/num.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/bool.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/array.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/code.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/all.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/str.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/obj.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/cistr.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/float.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/int.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/re.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/any.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH/buf.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js/TH.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/undef.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/hash.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/num.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/bool.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/array.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/code.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/all.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/str.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/obj.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/cistr.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/float.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/Sortable.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/Comparable.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/int.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/HasElems.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/re.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/any.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH/buf.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human/TH.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/Prog.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/undef.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/hash.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/num.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/bool.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/array.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/code.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/all.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/str.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/obj.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/cistr.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/float.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/int.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/re.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/any.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH/buf.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/perl/TH.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/js.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/TH.pm
Data-Sah-0.22/lib/Data/Sah/Compiler/human.pm
Data-Sah-0.22/lib/Data/Sah/Manual/
Data-Sah-0.22/lib/Data/Sah/Manual/Contributing.pod
Data-Sah-0.22/lib/Data/Sah/Manual/Extending.pod
Data-Sah-0.22/lib/Data/Sah/Lang.pm
Data-Sah-0.22/lib/Data/Sah/Compiler.pm
Data-Sah-0.22/lib/Data/Sah/Human.pm
Data-Sah-0.22/lib/Data/Sah/Type/
Data-Sah-0.22/lib/Data/Sah/Type/undef.pm
Data-Sah-0.22/lib/Data/Sah/Type/hash.pm
Data-Sah-0.22/lib/Data/Sah/Type/num.pm
Data-Sah-0.22/lib/Data/Sah/Type/bool.pm
Data-Sah-0.22/lib/Data/Sah/Type/array.pm
Data-Sah-0.22/lib/Data/Sah/Type/code.pm
Data-Sah-0.22/lib/Data/Sah/Type/all.pm
Data-Sah-0.22/lib/Data/Sah/Type/str.pm
Data-Sah-0.22/lib/Data/Sah/Type/obj.pm
Data-Sah-0.22/lib/Data/Sah/Type/cistr.pm
Data-Sah-0.22/lib/Data/Sah/Type/BaseType.pm
Data-Sah-0.22/lib/Data/Sah/Type/float.pm
Data-Sah-0.22/lib/Data/Sah/Type/Sortable.pm
Data-Sah-0.22/lib/Data/Sah/Type/Comparable.pm
Data-Sah-0.22/lib/Data/Sah/Type/int.pm
Data-Sah-0.22/lib/Data/Sah/Type/HasElems.pm
Data-Sah-0.22/lib/Data/Sah/Type/re.pm
Data-Sah-0.22/lib/Data/Sah/Type/any.pm
Data-Sah-0.22/lib/Data/Sah/Type/buf.pm
Data-Sah-0.22/MANIFEST.SKIP
Data-Sah-0.22/README
Data-Sah-0.22/META.json
Data-Sah-0.22/Makefile.PL
Data-Sah-0.22/dist.ini
Data-Sah-0.22/t/
Data-Sah-0.22/t/release-rinci.t
Data-Sah-0.22/t/01-basics.t
Data-Sah-0.22/t/release-pod-coverage.t
Data-Sah-0.22/t/perl-type-obj.t
Data-Sah-0.22/t/perl-type-bool.t
Data-Sah-0.22/t/spectest-js.t
Data-Sah-0.22/t/spectest-human.t-
Data-Sah-0.22/t/perl-type-re.t
Data-Sah-0.22/t/perl-type-code.t
Data-Sah-0.22/t/00-compile.t
Data-Sah-0.22/t/human-id_ID.t
Data-Sah-0.22/t/spectest-perl.t
Data-Sah-0.22/t/perl-type-float.t
Data-Sah-0.22/t/99-various.t
Data-Sah-0.22/t/human-en_US.t
Data-Sah-0.22/t/testlib.pl
Data-Sah-0.22/t/perl-type-str.t
Data-Sah-0.22/t/release-pod-syntax.t
Data-Sah-0.22/weaver.ini
Data-Sah-0.22/META.yml
CPAN.pm: Building S/SH/SHARYANTO/Data-Sah-0.22.tar.gz
>>> C:\Perl64-5.18\bin\perl.exe Makefile.PL
Warning: prerequisite Language::Expr 0.13 not found.
Warning: prerequisite Language::Expr::Interpreter::VarEnumer 0.13 not found.
Checking if your kit is complete...
Looks good
Generating a dmake-style Makefile
Writing Makefile for Data::Sah
Writing MYMETA.yml and MYMETA.json
---- Unsatisfied dependencies detected during ----
---- SHARYANTO/Data-Sah-0.22.tar.gz ----
Language::Expr [requires]
Language::Expr::Interpreter::VarEnumer [requires]
Running make test
Delayed until after prerequisites
Running test for module 'Language::Expr'
Running make for S/SH/SHARYANTO/Language-Expr-0.21.tar.gz
Checksum for C:\cpanfly-5.18\var\cpan\sources\authors\id\S\SH\SHARYANTO\Language-Expr-0.21.tar.gz ok
Language-Expr-0.21/
Language-Expr-0.21/Changes
Language-Expr-0.21/LICENSE
Language-Expr-0.21/MANIFEST
Language-Expr-0.21/lib/
Language-Expr-0.21/lib/Language/
Language-Expr-0.21/lib/Language/Expr/
Language-Expr-0.21/lib/Language/Expr/Parser.pm
Language-Expr-0.21/lib/Language/Expr/EvaluatorRole.pm
Language-Expr-0.21/lib/Language/Expr/Interpreter/
Language-Expr-0.21/lib/Language/Expr/Interpreter/VarEnumer.pm
Language-Expr-0.21/lib/Language/Expr/Interpreter/Dummy.pm
Language-Expr-0.21/lib/Language/Expr/Interpreter/Default.pm
Language-Expr-0.21/lib/Language/Expr/Compiler/
Language-Expr-0.21/lib/Language/Expr/Compiler/Perl.pm
Language-Expr-0.21/lib/Language/Expr/Compiler/JS.pm
Language-Expr-0.21/lib/Language/Expr/Compiler/PHP.pm
Language-Expr-0.21/lib/Language/Expr/Compiler/Base.pm
Language-Expr-0.21/lib/Language/Expr/Manual/
Language-Expr-0.21/lib/Language/Expr/Manual/Syntax.pod
Language-Expr-0.21/lib/Language/Expr/Evaluator.pm
Language-Expr-0.21/lib/Language/Expr.pm
Language-Expr-0.21/MANIFEST.SKIP
Language-Expr-0.21/README
Language-Expr-0.21/META.json
Language-Expr-0.21/dist.ini
Language-Expr-0.21/t-disabled/
Language-Expr-0.21/t-disabled/eval-js.t
Language-Expr-0.21/t-disabled/eval-php.t
Language-Expr-0.21/t/
Language-Expr-0.21/t/release-rinci.t
Language-Expr-0.21/t/01-basics.t
Language-Expr-0.21/t/release-pod-coverage.t
Language-Expr-0.21/t/hook_var.t
Language-Expr-0.21/t/hook_func.t
Language-Expr-0.21/t/00-compile.t
Language-Expr-0.21/t/stdtests.pl
Language-Expr-0.21/t/testlib.pl
Language-Expr-0.21/t/release-pod-syntax.t
Language-Expr-0.21/t/enum_vars.t
Language-Expr-0.21/t/eval.t
Language-Expr-0.21/Build.PL
Language-Expr-0.21/META.yml
CPAN.pm: Building S/SH/SHARYANTO/Language-Expr-0.21.tar.gz
>>> C:\Perl64-5.18\bin\perl.exe Build.PL
Created MYMETA.yml and MYMETA.json
Creating new 'Build' script for 'Language-Expr' version '0.21'
>>> C:\Perl64-5.18\bin\perl.exe ./Build
Building Language-Expr
SHARYANTO/Language-Expr-0.21.tar.gz
C:\Perl64-5.18\bin\perl.exe ./Build -- OK
Running Build test
>>> C:\Perl64-5.18\bin\perl.exe ./Build test verbose=1
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
t/00-compile.t ............
ok 1 - Language/Expr.pm loaded ok
ok 2 - Language/Expr/Compiler/Base.pm loaded ok
ok 3 - Language/Expr/Compiler/JS.pm loaded ok
ok 4 - Language/Expr/Compiler/PHP.pm loaded ok
ok 5 - Language/Expr/Compiler/Perl.pm loaded ok
ok 6 - Language/Expr/Evaluator.pm loaded ok
ok 7 - Language/Expr/EvaluatorRole.pm loaded ok
ok 8 - Language/Expr/Interpreter/Default.pm loaded ok
ok 9 - Language/Expr/Interpreter/Dummy.pm loaded ok
ok 10 - Language/Expr/Interpreter/VarEnumer.pm loaded ok
ok 11 - Language/Expr/Parser.pm loaded ok
1..11
ok
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Can't call method "rule_dquotestr" on an undefined value at (eval 38) line 994.
# Looks like your test exited with 255 before it could output anything.
t/01-basics.t .............
1..8
Dubious, test returned 255 (wstat 65280, 0xff00)
Failed 8/8 subtests
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Can't call method "rule_array" on an undefined value at (eval 32) line 809.
# Looks like your test exited with 255 before it could output anything.
t/enum_vars.t .............
1..9
Dubious, test returned 255 (wstat 65280, 0xff00)
Failed 9/9 subtests
Name "Language::Expr::Compiler::Perl::hash1" used only once: possible typo at t/eval.t line 17.
Name "Language::Expr::Compiler::Perl::b" used only once: possible typo at t/eval.t line 15.
Name "Language::Expr::Compiler::Perl::a" used only once: possible typo at t/eval.t line 14.
Name "Language::Expr::Compiler::Perl::ary1" used only once: possible typo at t/eval.t line 16.
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Can't call method "rule_num" on an undefined value at (eval 36) line 903.
# Looks like your test exited with 255 before it could output anything.
t/eval.t ..................
1..354
Dubious, test returned 255 (wstat 65280, 0xff00)
Failed 354/354 subtests
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Can't call method "rule_var" on an undefined value at (eval 32) line 1006.
# Looks like your test exited with 255 before it could output anything.
t/hook_func.t .............
1..6
Dubious, test returned 255 (wstat 65280, 0xff00)
Failed 6/6 subtests
Warning: Regexp::Grammars is currently unsupported under Perl 5.18.
Perl 5.18 changed how 'qr' constant overloadings are parsed and the
scope in which they are subsequently compiled. This change currently
make it impossible to reliably create 'qr' overloadings that inject
code blocks into a regex, as it prevents the overloaded regexes from
compiling properly in many cases, even with an explicit 'use re
"eval"' in scope.
These problems have been reported, and the brave volunteers of P5P are
currently working on fixes. However, these will not be available until
at least 5.18.2.
Because Regexp::Grammars relies on 'qr' overloads to inject code blocks
into regexes, the module is curently not compatible with Perl 5.18. It
may continue to work in some limited cases, but is no longer reliable.
At present, if you rely on Regexp::Grammars for your parsing needs, your
alternatives are either not to upgrade to Perl 5.18, to livce with the
problems until they are resolved (in Perl 5.18.2, we hope), or else to
consider switching to another parsing system, such as Marpa.
We deeply regret that Regexp::Grammars cannot currently be maintained
completelt due to these backwards-incompatible changes and bugs in
Perl 5.18.
at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 24.
Useless use of '\'; doesn't escape metacharacter '{' at C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt\blib\lib/Language/Expr/Parser.pm line 266.
Can't call method "rule_var" on an undefined value at (eval 32) line 1006.
# Looks like your test exited with 255 before it could output anything.
t/hook_var.t ..............
1..6
Dubious, test returned 255 (wstat 65280, 0xff00)
Failed 6/6 subtests
t/release-pod-coverage.t .. skipped: these tests are for release candidate testing
t/release-pod-syntax.t .... skipped: these tests are for release candidate testing
t/release-rinci.t ......... skipped: these tests are for release candidate testing
Test Summary Report
-------------------
t/01-basics.t (Wstat: 65280 Tests: 0 Failed: 0)
Non-zero exit status: 255
Parse errors: Bad plan. You planned 8 tests but ran 0.
t/enum_vars.t (Wstat: 65280 Tests: 0 Failed: 0)
Non-zero exit status: 255
Parse errors: Bad plan. You planned 9 tests but ran 0.
t/eval.t (Wstat: 65280 Tests: 0 Failed: 0)
Non-zero exit status: 255
Parse errors: Bad plan. You planned 354 tests but ran 0.
t/hook_func.t (Wstat: 65280 Tests: 0 Failed: 0)
Non-zero exit status: 255
Parse errors: Bad plan. You planned 6 tests but ran 0.
t/hook_var.t (Wstat: 65280 Tests: 0 Failed: 0)
Non-zero exit status: 255
Parse errors: Bad plan. You planned 6 tests but ran 0.
Files=9, Tests=11, 7 wallclock secs ( 0.08 usr + 0.03 sys = 0.11 CPU)
Result: FAIL
Failed 5/9 test programs. 0/11 subtests failed.
SHARYANTO/Language-Expr-0.21.tar.gz
C:\Perl64-5.18\bin\perl.exe ./Build test verbose=1 -- NOT OK
//hint// to see the cpan-testers results for installing this module, try:
reports SHARYANTO/Language-Expr-0.21.tar.gz
Running test for module 'Language::Expr::Interpreter::VarEnumer'
Running Build for S/SH/SHARYANTO/Language-Expr-0.21.tar.gz
Has already been unwrapped into directory C:\cpanfly-5.18\var\cpan\build\Language-Expr-0.21-BZX9nt
Has already been made
Running Build test
Won't repeat unsuccessful test during this command
Has already been tested within this command
Running make for S/SH/SHARYANTO/Data-Sah-0.22.tar.gz
Has already been unwrapped into directory C:\cpanfly-5.18\var\cpan\build\Data-Sah-0.22-P_AH5D
CPAN.pm: Building S/SH/SHARYANTO/Data-Sah-0.22.tar.gz
Warning: Prerequisite 'Language::Expr::Interpreter::VarEnumer => 0.13' for 'SHARYANTO/Data-Sah-0.22.tar.gz' failed when processing 'SHARYANTO/Language-Expr-0.21.tar.gz' with 'make_test => NO'. Continuing, but chances to succeed are limited.
Warning: Prerequisite 'Language::Expr => 0.13' for 'SHARYANTO/Data-Sah-0.22.tar.gz' failed when processing 'SHARYANTO/Language-Expr-0.21.tar.gz' with 'make_test => NO'. Continuing, but chances to succeed are limited.
>>> dmake
cp lib/Data/Sah/Compiler/Prog.pm blib\lib\Data\Sah\Compiler\Prog.pm
cp lib/Data/Sah/Compiler/Prog/TH/any.pm blib\lib\Data\Sah\Compiler\Prog\TH\any.pm
cp lib/Data/Sah.pm blib\lib\Data\Sah.pm
cp lib/Data/Sah/Compiler/human/TH/all.pm blib\lib\Data\Sah\Compiler\human\TH\all.pm
cp lib/Data/Sah/Compiler/human/TH/any.pm blib\lib\Data\Sah\Compiler\human\TH\any.pm
cp lib/Data/Sah/Compiler/TH.pm blib\lib\Data\Sah\Compiler\TH.pm
cp lib/Data/Sah/Compiler/human/TH/Sortable.pm blib\lib\Data\Sah\Compiler\human\TH\Sortable.pm
cp lib/Data/Sah/Compiler/human/TH/Comparable.pm blib\lib\Data\Sah\Compiler\human\TH\Comparable.pm
cp lib/Data/Sah/Compiler/Prog/TH/all.pm blib\lib\Data\Sah\Compiler\Prog\TH\all.pm
cp lib/Data/Sah/Compiler/human.pm blib\lib\Data\Sah\Compiler\human.pm
cp lib/Data/Sah/Compiler/human/TH.pm blib\lib\Data\Sah\Compiler\human\TH.pm
cp lib/Data/Sah/Compiler/TextResultRole.pm blib\lib\Data\Sah\Compiler\TextResultRole.pm
cp lib/Data/Sah/Compiler/Prog/TH.pm blib\lib\Data\Sah\Compiler\Prog\TH.pm
cp lib/Data/Sah/Compiler.pm blib\lib\Data\Sah\Compiler.pm
cp lib/Data/Sah/Compiler/human/TH/HasElems.pm blib\lib\Data\Sah\Compiler\human\TH\HasElems.pm
cp lib/Data/Sah/Compiler/human/TH/array.pm blib\lib\Data\Sah\Compiler\human\TH\array.pm
cp lib/Data/Sah/Compiler/human/TH/buf.pm blib\lib\Data\Sah\Compiler\human\TH\buf.pm
cp lib/Data/Sah/Compiler/js/TH/all.pm blib\lib\Data\Sah\Compiler\js\TH\all.pm
cp lib/Data/Sah/Compiler/human/TH/num.pm blib\lib\Data\Sah\Compiler\human\TH\num.pm
cp lib/Data/Sah/Compiler/human/TH/obj.pm blib\lib\Data\Sah\Compiler\human\TH\obj.pm
cp lib/Data/Sah/Compiler/human/TH/undef.pm blib\lib\Data\Sah\Compiler\human\TH\undef.pm
cp lib/Data/Sah/Compiler/human/TH/cistr.pm blib\lib\Data\Sah\Compiler\human\TH\cistr.pm
cp lib/Data/Sah/Compiler/js/TH.pm blib\lib\Data\Sah\Compiler\js\TH.pm
cp lib/Data/Sah/Compiler/human/TH/float.pm blib\lib\Data\Sah\Compiler\human\TH\float.pm
cp lib/Data/Sah/Compiler/js.pm blib\lib\Data\Sah\Compiler\js.pm
cp lib/Data/Sah/Compiler/human/TH/hash.pm blib\lib\Data\Sah\Compiler\human\TH\hash.pm
cp lib/Data/Sah/Compiler/human/TH/code.pm blib\lib\Data\Sah\Compiler\human\TH\code.pm
cp lib/Data/Sah/Compiler/human/TH/str.pm blib\lib\Data\Sah\Compiler\human\TH\str.pm
cp lib/Data/Sah/Compiler/human/TH/int.pm blib\lib\Data\Sah\Compiler\human\TH\int.pm
cp lib/Data/Sah/Compiler/human/TH/re.pm blib\lib\Data\Sah\Compiler\human\TH\re.pm
cp lib/Data/Sah/Compiler/human/TH/bool.pm blib\lib\Data\Sah\Compiler\human\TH\bool.pm
cp lib/Data/Sah/Compiler/js/TH/re.pm blib\lib\Data\Sah\Compiler\js\TH\re.pm
cp lib/Data/Sah/Compiler/js/TH/bool.pm blib\lib\Data\Sah\Compiler\js\TH\bool.pm
cp lib/Data/Sah/Compiler/js/TH/any.pm blib\lib\Data\Sah\Compiler\js\TH\any.pm
cp lib/Data/Sah/Compiler/js/TH/str.pm blib\lib\Data\Sah\Compiler\js\TH\str.pm
cp lib/Data/Sah/Compiler/js/TH/buf.pm blib\lib\Data\Sah\Compiler\js\TH\buf.pm
cp lib/Data/Sah/Compiler/js/TH/code.pm blib\lib\Data\Sah\Compiler\js\TH\code.pm
cp lib/Data/Sah/Compiler/js/TH/int.pm blib\lib\Data\Sah\Compiler\js\TH\int.pm
cp lib/Data/Sah/Compiler/perl.pm blib\lib\Data\Sah\Compiler\perl.pm
cp lib/Data/Sah/Compiler/js/TH/num.pm blib\lib\Data\Sah\Compiler\js\TH\num.pm
cp lib/Data/Sah/Compiler/perl/TH.pm blib\lib\Data\Sah\Compiler\perl\TH.pm
cp lib/Data/Sah/Compiler/js/TH/array.pm blib\lib\Data\Sah\Compiler\js\TH\array.pm
cp lib/Data/Sah/Compiler/js/TH/float.pm blib\lib\Data\Sah\Compiler\js\TH\float.pm
cp lib/Data/Sah/Compiler/js/TH/cistr.pm blib\lib\Data\Sah\Compiler\js\TH\cistr.pm
cp lib/Data/Sah/Compiler/js/TH/hash.pm blib\lib\Data\Sah\Compiler\js\TH\hash.pm
cp lib/Data/Sah/Compiler/js/TH/undef.pm blib\lib\Data\Sah\Compiler\js\TH\undef.pm
cp lib/Data/Sah/Compiler/js/TH/obj.pm blib\lib\Data\Sah\Compiler\js\TH\obj.pm
cp lib/Data/Sah/Compiler/perl/TH/int.pm blib\lib\Data\Sah\Compiler\perl\TH\int.pm
cp lib/Data/Sah/Compiler/perl/TH/num.pm blib\lib\Data\Sah\Compiler\perl\TH\num.pm
cp lib/Data/Sah/Compiler/perl/TH/hash.pm blib\lib\Data\Sah\Compiler\perl\TH\hash.pm
cp lib/Data/Sah/Compiler/perl/TH/undef.pm blib\lib\Data\Sah\Compiler\perl\TH\undef.pm
cp lib/Data/Sah/Compiler/perl/TH/any.pm blib\lib\Data\Sah\Compiler\perl\TH\any.pm
cp lib/Data/Sah/Compiler/perl/TH/array.pm blib\lib\Data\Sah\Compiler\perl\TH\array.pm
cp lib/Data/Sah/Human.pm blib\lib\Data\Sah\Human.pm
cp lib/Data/Sah/Compiler/perl/TH/cistr.pm blib\lib\Data\Sah\Compiler\perl\TH\cistr.pm
cp lib/Data/Sah/Compiler/perl/TH/all.pm blib\lib\Data\Sah\Compiler\perl\TH\all.pm
cp lib/Data/Sah/Compiler/perl/TH/bool.pm blib\lib\Data\Sah\Compiler\perl\TH\bool.pm
cp lib/Data/Sah/Compiler/perl/TH/code.pm blib\lib\Data\Sah\Compiler\perl\TH\code.pm
cp lib/Data/Sah/Compiler/perl/TH/obj.pm blib\lib\Data\Sah\Compiler\perl\TH\obj.pm
cp lib/Data/Sah/Compiler/perl/TH/float.pm blib\lib\Data\Sah\Compiler\perl\TH\float.pm
cp lib/Data/Sah/Compiler/perl/TH/str.pm blib\lib\Data\Sah\Compiler\perl\TH\str.pm
cp lib/Data/Sah/Compiler/perl/TH/buf.pm blib\lib\Data\Sah\Compiler\perl\TH\buf.pm
cp lib/Data/Sah/Compiler/perl/TH/re.pm blib\lib\Data\Sah\Compiler\perl\TH\re.pm
cp lib/Data/Sah/Schema/Common.pm blib\lib\Data\Sah\Schema\Common.pm
cp lib/Data/Sah/Type/cistr.pm blib\lib\Data\Sah\Type\cistr.pm
cp lib/Data/Sah/Type/buf.pm blib\lib\Data\Sah\Type\buf.pm
cp lib/Data/Sah/Type/array.pm blib\lib\Data\Sah\Type\array.pm
cp lib/Data/Sah/Manual/Contributing.pod blib\lib\Data\Sah\Manual\Contributing.pod
cp lib/Data/Sah/Type/BaseType.pm blib\lib\Data\Sah\Type\BaseType.pm
cp lib/Data/Sah/Schema/sah.pm blib\lib\Data\Sah\Schema\sah.pm
cp lib/Data/Sah/Lang/fr_FR.pm blib\lib\Data\Sah\Lang\fr_FR.pm
cp lib/Data/Sah/Type/Comparable.pm blib\lib\Data\Sah\Type\Comparable.pm
cp lib/Data/Sah/Lang/id_ID.pm blib\lib\Data\Sah\Lang\id_ID.pm
cp lib/Data/Sah/Type/any.pm blib\lib\Data\Sah\Type\any.pm
cp lib/Data/Sah/Type/code.pm blib\lib\Data\Sah\Type\code.pm
cp lib/Data/Sah/Type/all.pm blib\lib\Data\Sah\Type\all.pm
cp lib/Data/Sah/Type/HasElems.pm blib\lib\Data\Sah\Type\HasElems.pm
cp lib/Data/Sah/Type/bool.pm blib\lib\Data\Sah\Type\bool.pm
cp lib/Data/Sah/Manual/Extending.pod blib\lib\Data\Sah\Manual\Extending.pod
cp lib/Data/Sah/JS.pm blib\lib\Data\Sah\JS.pm
cp lib/Data/Sah/Lang.pm blib\lib\Data\Sah\Lang.pm
cp lib/Data/Sah/Lang/zh_CN.pm blib\lib\Data\Sah\Lang\zh_CN.pm
cp lib/Data/Sah/Type/Sortable.pm blib\lib\Data\Sah\Type\Sortable.pm
cp lib/Data/Sah/Type/float.pm blib\lib\Data\Sah\Type\float.pm
cp lib/Data/Sah/Util/Func.pm blib\lib\Data\Sah\Util\Func.pm
cp lib/Data/Sah/Util/TypeX.pm blib\lib\Data\Sah\Util\TypeX.pm
cp lib/Data/Sah/Type/str.pm blib\lib\Data\Sah\Type\str.pm
cp lib/Data/Sah/Type/num.pm blib\lib\Data\Sah\Type\num.pm
cp lib/Data/Sah/Type/undef.pm blib\lib\Data\Sah\Type\undef.pm
cp lib/Data/Sah/Type/re.pm blib\lib\Data\Sah\Type\re.pm
cp lib/Data/Sah/Type/hash.pm blib\lib\Data\Sah\Type\hash.pm
cp lib/Data/Sah/Type/int.pm blib\lib\Data\Sah\Type\int.pm
cp lib/Data/Sah/Type/obj.pm blib\lib\Data\Sah\Type\obj.pm
cp lib/Data/Sah/Util/Role.pm blib\lib\Data\Sah\Util\Role.pm
SHARYANTO/Data-Sah-0.22.tar.gz
dmake -- OK
Running make test
>>> dmake test TEST_VERBOSE=1
C:\Perl64-5.18\bin\perl.exe "-MExtUtils::Command::MM" "-MTest::Harness" "-e" "undef *Test::Harness::Switches; test_harness(1, 'blib\lib', 'blib\arch')" t/*.t
t/00-compile.t ............
1..92
ok 1 - Data/Sah.pm loaded ok
ok 2 - Data/Sah/Compiler.pm loaded ok
ok 3 - Data/Sah/Compiler/Prog.pm loaded ok
ok 4 - Data/Sah/Compiler/Prog/TH.pm loaded ok
ok 5 - Data/Sah/Compiler/Prog/TH/all.pm loaded ok
ok 6 - Data/Sah/Compiler/Prog/TH/any.pm loaded ok
ok 7 - Data/Sah/Compiler/TH.pm loaded ok
ok 8 - Data/Sah/Compiler/TextResultRole.pm loaded ok
ok 9 - Data/Sah/Compiler/human.pm loaded ok
ok 10 - Data/Sah/Compiler/human/TH.pm loaded ok
ok 11 - Data/Sah/Compiler/human/TH/Comparable.pm loaded ok
ok 12 - Data/Sah/Compiler/human/TH/HasElems.pm loaded ok
ok 13 - Data/Sah/Compiler/human/TH/Sortable.pm loaded ok
ok 14 - Data/Sah/Compiler/human/TH/all.pm loaded ok
ok 15 - Data/Sah/Compiler/human/TH/any.pm loaded ok
ok 16 - Data/Sah/Compiler/human/TH/array.pm loaded ok
ok 17 - Data/Sah/Compiler/human/TH/bool.pm loaded ok
ok 18 - Data/Sah/Compiler/human/TH/buf.pm loaded ok
ok 19 - Data/Sah/Compiler/human/TH/cistr.pm loaded ok
ok 20 - Data/Sah/Compiler/human/TH/code.pm loaded ok
ok 21 - Data/Sah/Compiler/human/TH/float.pm loaded ok
ok 22 - Data/Sah/Compiler/human/TH/hash.pm loaded ok
ok 23 - Data/Sah/Compiler/human/TH/int.pm loaded ok
ok 24 - Data/Sah/Compiler/human/TH/num.pm loaded ok
ok 25 - Data/Sah/Compiler/human/TH/obj.pm loaded ok
ok 26 - Data/Sah/Compiler/human/TH/re.pm loaded ok
ok 27 - Data/Sah/Compiler/human/TH/str.pm loaded ok
ok 28 - Data/Sah/Compiler/human/TH/undef.pm loaded ok
ok 29 - Data/Sah/Compiler/js.pm loaded ok
ok 30 - Data/Sah/Compiler/js/TH.pm loaded ok
ok 31 - Data/Sah/Compiler/js/TH/all.pm loaded ok
ok 32 - Data/Sah/Compiler/js/TH/any.pm loaded ok
ok 33 - Data/Sah/Compiler/js/TH/array.pm loaded ok
ok 34 - Data/Sah/Compiler/js/TH/bool.pm loaded ok
ok 35 - Data/Sah/Compiler/js/TH/buf.pm loaded ok
ok 36 - Data/Sah/Compiler/js/TH/cistr.pm loaded ok
ok 37 - Data/Sah/Compiler/js/TH/code.pm loaded ok
ok 38 - Data/Sah/Compiler/js/TH/float.pm loaded ok
ok 39 - Data/Sah/Compiler/js/TH/hash.pm loaded ok
ok 40 - Data/Sah/Compiler/js/TH/int.pm loaded ok
ok 41 - Data/Sah/Compiler/js/TH/num.pm loaded ok
ok 42 - Data/Sah/Compiler/js/TH/obj.pm loaded ok
ok 43 - Data/Sah/Compiler/js/TH/re.pm loaded ok
ok 44 - Data/Sah/Compiler/js/TH/str.pm loaded ok
ok 45 - Data/Sah/Compiler/js/TH/undef.pm loaded ok
ok 46 - Data/Sah/Compiler/perl.pm loaded ok
ok 47 - Data/Sah/Compiler/perl/TH.pm loaded ok
ok 48 - Data/Sah/Compiler/perl/TH/all.pm loaded ok
ok 49 - Data/Sah/Compiler/perl/TH/any.pm loaded ok
ok 50 - Data/Sah/Compiler/perl/TH/array.pm loaded ok
ok 51 - Data/Sah/Compiler/perl/TH/bool.pm loaded ok
ok 52 - Data/Sah/Compiler/perl/TH/buf.pm loaded ok
ok 53 - Data/Sah/Compiler/perl/TH/cistr.pm loaded ok
ok 54 - Data/Sah/Compiler/perl/TH/code.pm loaded ok
ok 55 - Data/Sah/Compiler/perl/TH/float.pm loaded ok
ok 56 - Data/Sah/Compiler/perl/TH/hash.pm loaded ok
ok 57 - Data/Sah/Compiler/perl/TH/int.pm loaded ok
ok 58 - Data/Sah/Compiler/perl/TH/num.pm loaded ok
ok 59 - Data/Sah/Compiler/perl/TH/obj.pm loaded ok
ok 60 - Data/Sah/Compiler/perl/TH/re.pm loaded ok
ok 61 - Data/Sah/Compiler/perl/TH/str.pm loaded ok
ok 62 - Data/Sah/Compiler/perl/TH/undef.pm loaded ok
ok 63 - Data/Sah/Human.pm loaded ok
ok 64 - Data/Sah/JS.pm loaded ok
ok 65 - Data/Sah/Lang.pm loaded ok
ok 66 - Data/Sah/Lang/fr_FR.pm loaded ok
ok 67 - Data/Sah/Lang/id_ID.pm loaded ok
ok 68 - Data/Sah/Lang/zh_CN.pm loaded ok
ok 69 - Data/Sah/Schema/Common.pm loaded ok
ok 70 - Data/Sah/Schema/sah.pm loaded ok
ok 71 - Data/Sah/Type/BaseType.pm loaded ok
ok 72 - Data/Sah/Type/Comparable.pm loaded ok
ok 73 - Data/Sah/Type/HasElems.pm loaded ok
ok 74 - Data/Sah/Type/Sortable.pm loaded ok
ok 75 - Data/Sah/Type/all.pm loaded ok
ok 76 - Data/Sah/Type/any.pm loaded ok
ok 77 - Data/Sah/Type/array.pm loaded ok
ok 78 - Data/Sah/Type/bool.pm loaded ok
ok 79 - Data/Sah/Type/buf.pm loaded ok
ok 80 - Data/Sah/Type/cistr.pm loaded ok
ok 81 - Data/Sah/Type/code.pm loaded ok
ok 82 - Data/Sah/Type/float.pm loaded ok
ok 83 - Data/Sah/Type/hash.pm loaded ok
ok 84 - Data/Sah/Type/int.pm loaded ok
ok 85 - Data/Sah/Type/num.pm loaded ok
ok 86 - Data/Sah/Type/obj.pm loaded ok
ok 87 - Data/Sah/Type/re.pm loaded ok
ok 88 - Data/Sah/Type/str.pm loaded ok
ok 89 - Data/Sah/Type/undef.pm loaded ok
ok 90 - Data/Sah/Util/Func.pm loaded ok
ok 91 - Data/Sah/Util/Role.pm loaded ok
ok 92 - Data/Sah/Util/TypeX.pm loaded ok
ok
t/01-basics.t .............
# Subtest: compile()
# Subtest: on_unhandled_clause option
ok 1 - die (default)
ok 2 - warn
ok 3 - ignore
1..3
ok 1 - on_unhandled_clause option
# Subtest: on_unhandled_attr option
ok 1 - die (default)
ok 2 - warn
ok 3 - ignore
1..3
ok 2 - on_unhandled_attr option
# Subtest: skip_clause option
ok 1
ok 2 - skip_clause in gen_validator() 1
ok 3 - skip_clause in gen_validator() 2
ok 4 - skip_clause in gen_validator() 3
1..4
ok 3 - skip_clause option
1..3
ok 1 - compile()
1..1
ok
# node.js not available, skipping JS test
t/99-various.t ............
# Subtest: [2014-01-03 ] req_keys clash between $_ and $dt
# Subtest: perl
ok 1 - [] validates
ok 2 - ['a'] doesn't validate
ok 3 - [{}] doesn't validate
ok 4 - [{b=>1}] doesn't validate
ok 5 - [{a=>1}] validates
1..5
ok 1 - perl
1..1
ok 1 - [2014-01-03 ] req_keys clash between $_ and $dt
1..1
ok
t/human-en_US.t ...........
# Subtest: integer
ok 1 - result
1..1
ok 1 - integer
# Subtest: integer
ok 1 - result
1..1
ok 2 - integer
# Subtest: integer, must be at least 1
ok 1 - result
1..1
ok 3 - integer, must be at least 1
# Subtest: integer, must be at least 1, must be at most 10
ok 1 - result
1..1
ok 4 - integer, must be at least 1, must be at most 10
# Subtest: integer, must be divisible by 2 and 5
ok 1 - result
1..1
ok 5 - integer, must be divisible by 2 and 5
# Subtest: integer, must be divisible by all of [2,3,5]
ok 1 - result
1..1
ok 6 - integer, must be divisible by all of [2,3,5]
# Subtest: integer, must be divisible by 2 or 5
ok 1 - result
1..1
ok 7 - integer, must be divisible by 2 or 5
# Subtest: integer, must be divisible by one of [2,3,5]
ok 1 - result
1..1
ok 8 - integer, must be divisible by one of [2,3,5]
# Subtest: integer, must not be divisible by 5
ok 1 - result
1..1
ok 9 - integer, must not be divisible by 5
# Subtest: array of integers
ok 1 - result
1..1
ok 10 - array of integers
# Subtest: (?^x:array .+ each\sarray\selement\smust\sbe: .+
# integer .+ at\sleast\s1)
ok 1 - result
1..1
ok 11 - (?^x:array .+ each\sarray\selement\smust\sbe: .+
# integer .+ at\sleast\s1)
# Subtest: array, 1st element must be: integer
ok 1 - result
1..1
ok 12 - array, 1st element must be: integer
# Subtest: (?^x:must\sbe\sall\sof\sthe\sfollowing: .+
# integer.+even .+
# integer.+divisible\sby\s5 .+
# )
ok 1 - result
1..1
ok 13 - (?^x:must\sbe\sall\sof\sthe\sfollowing: .+
# integer.+even .+
# integer.+divisible\sby\s5 .+
# )
# Subtest: hash, field f must be: decimal number, field i must be: (integer, must be at least 0)
ok 1 - result
1..1
ok 14 - hash, field f must be: decimal number, field i must be: (integer, must be at least 0)
1..14
ok
t/human-id_ID.t ...........
# Subtest: bilangan bulat
ok 1 - result
1..1
ok 1 - bilangan bulat
# Subtest: larik, elemen ke-1 harus: bilangan bulat
ok 1 - result
1..1
ok 2 - larik, elemen ke-1 harus: bilangan bulat
1..2
ok
t/perl-type-bool.t ........
ok 1
ok 2
ok 3
1..3
ok
t/perl-type-code.t ........
ok 1
ok 2
1..2
ok
t/perl-type-float.t .......
ok 1 - 1 vs ["float", "is_nan", 1]
ok 2 - Inf vs ["float", "is_nan", 1]
ok 3 - NaN vs ["float", "is_nan", 1]
ok 4 - 1 vs ["float", "is_inf", 1]
ok 5 - NaN vs ["float", "is_inf", 1]
ok 6 - -Inf vs ["float", "is_inf", 1]
ok 7 - Inf vs ["float", "is_inf", 1]
ok 8 - 1 vs ["float", "is_pos_inf", 1]
ok 9 - NaN vs ["float", "is_pos_inf", 1]
ok 10 - -Inf vs ["float", "is_pos_inf", 1]
ok 11 - Inf vs ["float", "is_pos_inf", 1]
ok 12 - 1 vs ["float", "is_neg_inf", 1]
ok 13 - NaN vs ["float", "is_neg_inf", 1]
ok 14 - -Inf vs ["float", "is_neg_inf", 1]
ok 15 - Inf vs ["float", "is_neg_inf", 1]
1..15
ok
t/perl-type-obj.t .........
ok 1
ok 2
ok 3
ok 4
ok 5
ok 6
ok 7
ok 8
ok 9
ok 10
ok 11
1..11
ok
t/perl-type-re.t ..........
ok 1
ok 2
ok 3
ok 4
ok 5
ok 6
1..6
ok
t/perl-type-str.t .........
ok 1
ok 2
1..2
ok
t/release-pod-coverage.t .. skipped: these tests are for release candidate testing
t/release-pod-syntax.t .... skipped: these tests are for release candidate testing
t/release-rinci.t ......... skipped: these tests are for release candidate testing
t/spectest-js.t ........... skipped: node.js is not available
# Loading 10-type-all.json ...
# Loading 10-type-any.json ...
# Loading 10-type-array.json ...
# Skipping test (tags=clause:check_each_index, type, type:array) check_each_index: clause check_each_index not yet implemented
# Skipping test (tags=clause:check_each_elem, type, type:array) check_each_elem: clause check_each_elem not yet implemented
# Skipping test (tags=clause:uniq, type, type:array) uniq=1: clause uniq not yet implemented
# Skipping test (tags=clause:uniq, type, type:array) uniq=0: clause uniq not yet implemented
# Skipping test (tags=clause:uniq, op, op:not, opshortcut, type, type:array) !uniq=1: clause uniq not yet implemented
# Skipping test (tags=clause:exists, type, type:array) exists: clause exists not yet implemented
# Skipping test (tags=prop:len, type, type:array) prop:len: properties are not yet implemented
# Skipping test (tags=prop:indices, type, type:array) prop:indices: properties are not yet implemented
# Skipping test (tags=prop:elems, type, type:array) prop:elems: properties are not yet implemented
# Loading 10-type-bool.json ...
# Skipping test (tags=clause:between, op, op:not, opshortcut, type, type:bool) !between (nok): currently failing
# Skipping test (tags=clause:between, op, op:not, opshortcut, type, type:bool) !between (ok): currently failing
# Skipping test (tags=clause:between, op, op:not, type, type:bool) between.op=not (nok): currently failing
# Skipping test (tags=clause:between, op, op:not, type, type:bool) between.op=not (ok): currently failing
# Skipping test (tags=clause:between, op, op:and, opshortcut, type, type:bool) between& (no items): currently failing
# Skipping test (tags=clause:between, op, op:and, opshortcut, type, type:bool) between& (ok): currently failing
# Skipping test (tags=clause:between, op, op:and, opshortcut, type, type:bool) between& (nok + ok): currently failing
# Skipping test (tags=clause:between, op, op:and, opshortcut, type, type:bool) between& (ok + nok): currently failing
# Skipping test (tags=clause:between, op, op:and, opshortcut, type, type:bool) between& (nok + nok): currently failing
# Skipping test (tags=clause:between, op, op:and, type, type:bool) between.op=and (ok): currently failing
# Skipping test (tags=clause:between, op, op:and, type, type:bool) between.op=and (nok + ok): currently failing
# Skipping test (tags=clause:between, op, op:and, type, type:bool) between.op=and (ok + nok): currently failing
# Skipping test (tags=clause:between, op, op:and, type, type:bool) between.op=and (nok + nok): currently failing
# Skipping test (tags=clause:between, op, op:or, opshortcut, type, type:bool) between| (no items): currently failing
# Skipping test (tags=clause:between, op, op:or, opshortcut, type, type:bool) between| (ok): currently failing
# Skipping test (tags=clause:between, op, op:or, opshortcut, type, type:bool) between| (nok + ok): currently failing
# Skipping test (tags=clause:between, op, op:or, opshortcut, type, type:bool) between| (ok + nok): currently failing
# Skipping test (tags=clause:between, op, op:or, opshortcut, type, type:bool) between| (nok + nok): currently failing
# Skipping test (tags=clause:between, op, op:or, type, type:bool) between.op=or (no items): currently failing
# Skipping test (tags=clause:between, op, op:or, type, type:bool) between.op=or (ok): currently failing
# Skipping test (tags=clause:between, op, op:or, type, type:bool) between.op=or (nok + ok): currently failing
# Skipping test (tags=clause:between, op, op:or, type, type:bool) between.op=or (ok + nok): currently failing
# Skipping test (tags=clause:between, op, op:or, type, type:bool) between.op=or (nok + nok): currently failing
# Skipping test (tags=clause:between, op, op:none, type, type:bool) between.op=none (empty items): currently failing
# Skipping test (tags=clause:between, op, op:none, type, type:bool) between.op=none (nok + nok): currently failing
# Skipping test (tags=clause:between, op, op:none, type, type:bool) between.op=none (nok + ok): currently failing
# Skipping test (tags=clause:between, op, op:none, type, type:bool) between.op=none (ok + nok): currently failing
# Skipping test (tags=clause:between, op, op:none, type, type:bool) between.op=none (ok + ok): currently failing
# Loading 10-type-buf.json ...
# Skipping test (tags=clause:check_each_index, type, type:buf) check_each_index: clause check_each_index not yet implemented
# Skipping test (tags=clause:check_each_elem, type, type:buf) check_each_elem: clause check_each_elem not yet implemented
# Skipping test (tags=clause:uniq, type, type:buf) uniq=1: clause uniq not yet implemented
# Skipping test (tags=clause:uniq, type, type:buf) uniq=0: clause uniq not yet implemented
# Skipping test (tags=clause:uniq, op, op:not, opshortcut, type, type:buf) !uniq=1: clause uniq not yet implemented
# Skipping test (tags=clause:exists, type, type:buf) exists: clause exists not yet implemented
# Skipping test (tags=prop:len, type, type:buf) prop:len: properties are not yet implemented
# Skipping test (tags=prop:indices, type, type:buf) prop:indices: properties are not yet implemented
# Skipping test (tags=prop:elems, type, type:buf) prop:elems: properties are not yet implemented
# Loading 10-type-cistr.json ...
# Skipping test (tags=clause:check_each_index, type, type:cistr) check_each_index: clause check_each_index not yet implemented
# Skipping test (tags=clause:check_each_elem, type, type:cistr) check_each_elem: clause check_each_elem not yet implemented
# Skipping test (tags=clause:uniq, type, type:cistr) uniq=1: clause uniq not yet implemented
# Skipping test (tags=clause:uniq, type, type:cistr) uniq=0: clause uniq not yet implemented
# Skipping test (tags=clause:uniq, op, op:not, opshortcut, type, type:cistr) !uniq=1: clause uniq not yet implemented
# Skipping test (tags=clause:exists, type, type:cistr) exists: clause exists not yet implemented
# Skipping test (tags=prop:len, type, type:cistr) prop:len: properties are not yet implemented
# Skipping test (tags=prop:indices, type, type:cistr) prop:indices: properties are not yet implemented
# Skipping test (tags=prop:elems, type, type:cistr) prop:elems: properties are not yet implemented
# Loading 10-type-float.json ...
# Loading 10-type-hash.json ...
# Skipping test (tags=clause:check_each_index, type, type:hash) check_each_index: clause check_each_index not yet implemented
# Skipping test (tags=clause:check_each_key, type, type:hash) check_each_key: clause check_each_key not yet implemented
# Skipping test (tags=clause:check_each_elem, type, type:hash) check_each_elem: clause check_each_elem not yet implemented
# Skipping test (tags=clause:check_each_value, type, type:hash) check_each_value: clause check_each_value not yet implemented
# Skipping test (tags=clause:uniq, type, type:hash) uniq=1: clause uniq not yet implemented
# Skipping test (tags=clause:uniq, type, type:hash) uniq=0: clause uniq not yet implemented
# Skipping test (tags=clause:uniq, op, op:not, opshortcut, type, type:hash) !uniq=1: clause uniq not yet implemented
# Skipping test (tags=clause:exists, type, type:hash) exists: clause exists not yet implemented
# Skipping test (tags=prop:len, type, type:hash) prop:len: properties are not yet implemented
# Skipping test (tags=prop:indices, type, type:hash) prop:indices: properties are not yet implemented
# Skipping test (tags=prop:keys, type, type:hash) prop:keys: properties are not yet implemented
# Skipping test (tags=prop:elems, type, type:hash) prop:elems: properties are not yet implemented
# Skipping test (tags=prop:values, type, type:hash) prop:values: properties are not yet implemented
# Skipping test (tags=prop:keys, type, type:hash) prop:keys: properties are not yet implemented
# Skipping test (tags=prop:values, type, type:hash) prop:values: properties are not yet implemented
# Loading 10-type-int.json ...
# Loading 10-type-num.json ...
# Loading 10-type-obj.json ...
# Skipping test (tags=prop:meths, type, type:obj) prop:meths (nok): properties are not yet implemented
# Skipping test (tags=prop:attrs, type, type:obj) prop:attrs (nok): properties are not yet implemented
# Loading 10-type-str.json ...
# Skipping test (tags=clause:check_each_index, type, type:str) check_each_index: clause check_each_index not yet implemented
# Skipping test (tags=clause:check_each_elem, type, type:str) check_each_elem: clause check_each_elem not yet implemented
# Skipping test (tags=clause:uniq, type, type:str) uniq=1: clause uniq not yet implemented
# Skipping test (tags=clause:uniq, type, type:str) uniq=0: clause uniq not yet implemented
# Skipping test (tags=clause:uniq, op, op:not, opshortcut, type, type:str) !uniq=1: clause uniq not yet implemented
# Skipping test (tags=clause:exists, type, type:str) exists: clause exists not yet implemented
# Skipping test (tags=prop:len, type, type:str) prop:len: properties are not yet implemented
# Skipping test (tags=prop:indices, type, type:str) prop:indices: properties are not yet implemented
# Skipping test (tags=prop:elems, type, type:str) prop:elems: properties are not yet implemented
# Loading 10-type-undef.json ...
t/spectest-perl.t .........
# Subtest: 00-normalize_schema.json
# Subtest: schema must be defined
ok 1 - dies
1..1
ok 1 - schema must be defined
# Subtest: string: type name must not be blank
ok 1 - dies
1..1
ok 2 - string: type name must not be blank
# Subtest: string: type name must be valid (ok)
ok 1 - result
ok 2 - doesn't die
1..2
ok 3 - string: type name must be valid (ok)
# Subtest: string: type name must be valid (ok, has namespace)
ok 1 - result
ok 2 - doesn't die
1..2
ok 4 - string: type name must be valid (ok, has namespace)
# Subtest: string: type name must be valid (fail, has whitespace)
ok 1 - dies
1..1
ok 5 - string: type name must be valid (fail, has whitespace)
# Subtest: string: type name must be valid (fail, starts with number)
ok 1 - dies
1..1
ok 6 - string: type name must be valid (fail, starts with number)
# Subtest: string: * suffix is allowed and normalized to req clause
ok 1 - result
ok 2 - doesn't die
1..2
ok 7 - string: * suffix is allowed and normalized to req clause
# Subtest: string: multiple * suffix is not allowed
ok 1 - dies
1..1
ok 8 - string: multiple * suffix is not allowed
# Subtest: array: must not be empty
ok 1 - dies
1..1
ok 9 - array: must not be empty
# Subtest: array: type name must be valid (ok)
ok 1 - result
ok 2 - doesn't die
1..2
ok 10 - array: type name must be valid (ok)
# Subtest: array: type name must be valid (fail, has whitespace)
ok 1 - dies
1..1
ok 11 - array: type name must be valid (fail, has whitespace)
# Subtest: array: * suffix is allowed and normalized to req clause
ok 1 - result
ok 2 - doesn't die
1..2
ok 12 - array: * suffix is allowed and normalized to req clause
# Subtest: array: clause set must be hash (ok, empty)
ok 1 - result
ok 2 - doesn't die
1..2
ok 13 - array: clause set must be hash (ok, empty)
# Subtest: array: clause set must be hash (ok, has some clauses)
ok 1 - result
ok 2 - doesn't die
1..2
ok 14 - array: clause set must be hash (ok, has some clauses)
# Subtest: array: clause set must be hash (fail, string)
ok 1 - dies
1..1
ok 15 - array: clause set must be hash (fail, string)
# Subtest: array: clause set must be hash (fail, array)
ok 1 - dies
1..1
ok 16 - array: clause set must be hash (fail, array)
# Subtest: array: clause name must be valid (fail, has whitespace)
ok 1 - dies
1..1
ok 17 - array: clause name must be valid (fail, has whitespace)
# Subtest: array: clause name must be valid (fail, starts with number)
ok 1 - dies
1..1
ok 18 - array: clause name must be valid (fail, starts with number)
# Subtest: array: * suffix is allowed and normalized to req clause (2-element-array schema)
ok 1 - result
ok 2 - doesn't die
1..2
ok 19 - array: * suffix is allowed and normalized to req clause (2-element-array schema)
# Subtest: array: * suffix is allowed and normalized to req clause (overrides existing req clause)
ok 1 - result
ok 2 - doesn't die
1..2
ok 20 - array: * suffix is allowed and normalized to req clause (overrides existing req clause)
# Subtest: array: clause attribute name must be valid (ok)
ok 1 - result
ok 2 - doesn't die
1..2
ok 21 - array: clause attribute name must be valid (ok)
# Subtest: array: clause attribute name must be valid (fail, has whitespace)
ok 1 - dies
1..1
ok 22 - array: clause attribute name must be valid (fail, has whitespace)
# Subtest: array: setting attribute on clause "" is permitted
ok 1 - result
ok 2 - doesn't die
1..2
ok 23 - array: setting attribute on clause "" is permitted
# Subtest: array: setting value attribute on clause "" using syntax "" is not permitted
ok 1 - dies
1..1
ok 24 - array: setting value attribute on clause "" using syntax "" is not permitted
# Subtest: array: flattened clause set is permitted
ok 1 - result
ok 2 - doesn't die
1..2
ok 25 - array: flattened clause set is permitted
# Subtest: array: flattened clause set is permitted (with * suffix)
ok 1 - result
ok 2 - doesn't die
1..2
ok 26 - array: flattened clause set is permitted (with * suffix)
# Subtest: array: flattened clause set is permitted (fail, odd number of elements)
ok 1 - dies
1..1
ok 27 - array: flattened clause set is permitted (fail, odd number of elements)
# Subtest: array: expression (clause=) is allowed on clause and normalized
ok 1 - result
ok 2 - doesn't die
1..2
ok 28 - array: expression (clause=) is allowed on clause and normalized
# Subtest: array: expression (clause=) is allowed on clause.attr and normalized
ok 1 - result
ok 2 - doesn't die
1..2
ok 29 - array: expression (clause=) is allowed on clause.attr and normalized
# Subtest: array: expression (clause=) must not conflict with literal value (fail)
ok 1 - dies
1..1
ok 30 - array: expression (clause=) must not conflict with literal value (fail)
# Subtest: array: expression (clause.attr=) must not conflict with literal value (fail)
ok 1 - dies
1..1
ok 31 - array: expression (clause.attr=) must not conflict with literal value (fail)
# Subtest: array: !clause is normalized
ok 1 - result
ok 2 - doesn't die
1..2
ok 32 - array: !clause is normalized
# Subtest: array: !clause.attr is not allowed
ok 1 - dies
1..1
ok 33 - array: !clause.attr is not allowed
# Subtest: array: clause| is normalized
ok 1 - result
ok 2 - doesn't die
1..2
ok 34 - array: clause| is normalized
# Subtest: array: clause.attr| is not allowed
ok 1 - dies
1..1
ok 35 - array: clause.attr| is not allowed
# Subtest: array: clause| value must be array (fail, not array)
ok 1 - dies
1..1
ok 36 - array: clause| value must be array (fail, not array)
# Subtest: array: clause& is normalized
ok 1 - result
ok 2 - doesn't die
1..2
ok 37 - array: clause& is normalized
# Subtest: array: clause.attr& is not allowed
ok 1 - dies
1..1
ok 38 - array: clause.attr& is not allowed
# Subtest: array: clause& value must be array (fail, not array)
ok 1 - dies
1..1
ok 39 - array: clause& value must be array (fail, not array)
# Subtest: array: !clause cannot be mixed with merge prefix
ok 1 - dies
1..1
ok 40 - array: !clause cannot be mixed with merge prefix
# Subtest: array: !clause cannot be mixed with expression
ok 1 - dies
1..1
ok 41 - array: !clause cannot be mixed with expression
# Subtest: array: clause| cannot be mixed with merge prefix
ok 1 - dies
1..1
ok 42 - array: clause| cannot be mixed with merge prefix
# Subtest: array: clause| cannot be mixed with expression
ok 1 - dies
1..1
ok 43 - array: clause| cannot be mixed with expression
# Subtest: array: clause& cannot be mixed with merge prefix
ok 1 - dies
1..1
ok 44 - array: clause& cannot be mixed with merge prefix
# Subtest: array: clause& cannot be mixed with expression
ok 1 - dies
1..1
ok 45 - array: clause& cannot be mixed with expression
# Subtest: array: clause, !clause, clause&, and clause| must not conflict with one another (fail, c & !c)
ok 1 - dies
1..1
ok 46 - array: clause, !clause, clause&, and clause| must not conflict with one another (fail, c & !c)
# Subtest: array: clause, !clause, clause&, and clause| must not conflict with one another (fail, c & c|)
ok 1 - dies
1..1
ok 47 - array: clause, !clause, clause&, and clause| must not conflict with one another (fail, c & c|)
# Subtest: array: clause, !clause, clause&, and clause| must not conflict with one another (fail, c & c&)
ok 1 - dies
1..1
ok 48 - array: clause, !clause, clause&, and clause| must not conflict with one another (fail, c & c&)
# Subtest: array: clause, !clause, clause&, and clause| must not conflict with one another (fail, !c & c|)
ok 1 - dies
1..1
ok 49 - array: clause, !clause, clause&, and clause| must not conflict with one another (fail, !c & c|)
# Subtest: array: clause, !clause, clause&, and clause| must not conflict with one another (fail, !c & c&)
ok 1 - dies
1..1
ok 50 - array: clause, !clause, clause&, and clause| must not conflict with one another (fail, !c & c&)
# Subtest: array: clause, !clause, clause&, and clause| must not conflict with one another (fail, c| & c&)
ok 1 - dies
1..1
ok 51 - array: clause, !clause, clause&, and clause| must not conflict with one another (fail, c| & c&)
# Subtest: array: merge prefix in clause is allowed
ok 1 - result
ok 2 - doesn't die
1..2
ok 52 - array: merge prefix in clause is allowed
# Subtest: array: clause(LANG) shortcut is allowed and normalized
ok 1 - result
ok 2 - doesn't die
1..2
ok 53 - array: clause(LANG) shortcut is allowed and normalized
# Subtest: array: clause.attr(LANG) shortcut is allowed and normalized
ok 1 - result
ok 2 - doesn't die
1..2
ok 54 - array: clause.attr(LANG) shortcut is allowed and normalized
# Subtest: array: clause(LANG) shortcut must not conflict with existing attribute
ok 1 - dies
1..1
ok 55 - array: clause(LANG) shortcut must not conflict with existing attribute
# Subtest: array: invalid clause(LANG) shortcut is not allowed (1)
ok 1 - dies
1..1
ok 56 - array: invalid clause(LANG) shortcut is not allowed (1)
# Subtest: array: invalid clause(LANG) shortcut is not allowed (2)
ok 1 - dies
1..1
ok 57 - array: invalid clause(LANG) shortcut is not allowed (2)
# Subtest: array: extras must be hash (ok)
ok 1 - result
ok 2 - doesn't die
1..2
ok 58 - array: extras must be hash (ok)
# Subtest: array: extras must be hash (fail, not hash)
ok 1 - dies
1..1
ok 59 - array: extras must be hash (fail, not hash)
# Subtest: array: def in extras must be hash (ok)
ok 1 - result
ok 2 - doesn't die
1..2
ok 60 - array: def in extras must be hash (ok)
# Subtest: array: def in extras must be hash (fail)
ok 1 - dies
1..1
ok 61 - array: def in extras must be hash (fail)
# Subtest: array: extra elements are not permitted
ok 1 - dies
1..1
ok 62 - array: extra elements are not permitted
# Subtest: hash form (old DS syntax) is no longer recognized
ok 1 - dies
1..1
ok 63 - hash form (old DS syntax) is no longer recognized
ok 64
1..64
ok 1 - 00-normalize_schema.json
# Subtest: 01-merge_clause_sets.json
# Subtest: no clause sets results in nothing done
ok 1 - result
ok 2 - doesn't die
1..2
ok 1 - no clause sets results in nothing done
# Subtest: a single clause set results in nothing done
ok 1 - result
ok 2 - doesn't die
1..2
ok 2 - a single clause set results in nothing done
# Subtest: no merge prefixes results in appending clause sets
ok 1 - result
ok 2 - doesn't die
1..2
ok 3 - no merge prefixes results in appending clause sets
# Subtest: normal mode merging replaces clauses on the left
ok 1 - result
ok 2 - doesn't die
1..2
ok 4 - normal mode merging replaces clauses on the left
# Subtest: additive mode merging adds values (array)
ok 1 - result
ok 2 - doesn't die
1..2
ok 5 - additive mode merging adds values (array)
# Subtest: concative mode merging concatenates values (string)
ok 1 - result
ok 2 - doesn't die
1..2
ok 6 - concative mode merging concatenates values (string)
# Subtest: subtractive mode merging concatenates values (int)
ok 1 - result
ok 2 - doesn't die
1..2
ok 7 - subtractive mode merging concatenates values (int)
# Subtest: delete mode merging deletes values
ok 1 - result
ok 2 - doesn't die
1..2
ok 8 - delete mode merging deletes values
# Subtest: keep mode prevents overriding of values
ok 1 - result
ok 2 - doesn't die
1..2
ok 9 - keep mode prevents overriding of values
ok 10
1..10
ok 2 - 01-merge_clause_sets.json
# Subtest: 10-type-all.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => 3,
# 'name' => 'of (nok + nok)',
# 'schema' => [
# 'all',
# 'of',
# [
# [
# 'int',
# 'div_by',
# 2
# ],
# [
# 'int',
# 'div_by',
# 5
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:all'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:all) of (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=type, type:all) of (nok + nok)
# {
# 'input' => 2,
# 'name' => 'of (ok + nok)',
# 'schema' => [
# 'all',
# 'of',
# [
# [
# 'int',
# 'div_by',
# 2
# ],
# [
# 'int',
# 'div_by',
# 5
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:all'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:all) of (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=type, type:all) of (ok + nok)
# {
# 'input' => 5,
# 'name' => 'of (nok + ok)',
# 'schema' => [
# 'all',
# 'of',
# [
# [
# 'int',
# 'div_by',
# 2
# ],
# [
# 'int',
# 'div_by',
# 5
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:all'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:all) of (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 3 - (tags=type, type:all) of (nok + ok)
# {
# 'input' => 10,
# 'name' => 'of (ok + ok)',
# 'schema' => [
# 'all',
# 'of',
# [
# [
# 'int',
# 'div_by',
# 2
# ],
# [
# 'int',
# 'div_by',
# 5
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:all'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:all) of (ok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 4 - (tags=type, type:all) of (ok + ok)
ok 5
1..5
ok 3 - 10-type-all.json
# Subtest: 10-type-any.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => 3,
# 'name' => 'of (nok + nok)',
# 'schema' => [
# 'any',
# 'of',
# [
# [
# 'int',
# 'div_by',
# 2
# ],
# [
# 'int',
# 'div_by',
# 5
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:any'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:any) of (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=type, type:any) of (nok + nok)
# {
# 'input' => 2,
# 'name' => 'of (ok + nok)',
# 'schema' => [
# 'any',
# 'of',
# [
# [
# 'int',
# 'div_by',
# 2
# ],
# [
# 'int',
# 'div_by',
# 5
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:any'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:any) of (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=type, type:any) of (ok + nok)
# {
# 'input' => 5,
# 'name' => 'of (nok + ok)',
# 'schema' => [
# 'any',
# 'of',
# [
# [
# 'int',
# 'div_by',
# 2
# ],
# [
# 'int',
# 'div_by',
# 5
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:any'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:any) of (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 3 - (tags=type, type:any) of (nok + ok)
# {
# 'input' => 10,
# 'name' => 'of (ok + ok)',
# 'schema' => [
# 'any',
# 'of',
# [
# [
# 'int',
# 'div_by',
# 2
# ],
# [
# 'int',
# 'div_by',
# 5
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:any'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:any) of (ok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 4 - (tags=type, type:any) of (ok + ok)
ok 5
1..5
ok 4 - 10-type-any.json
# Subtest: 10-type-array.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => [],
# 'name' => 'type check: must accept []',
# 'schema' => 'array',
# 'tags' => [
# 'type',
# 'type:array'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:array) type check: must accept []
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=type, type:array) type check: must accept []
# {
# 'input' => [
# '1',
# 'a'
# ],
# 'name' => 'type check: must accept [1, "a"]',
# 'schema' => 'array',
# 'tags' => [
# 'type',
# 'type:array'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:array) type check: must accept [1, "a"]
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=type, type:array) type check: must accept [1, "a"]
# {
# 'input' => [
# []
# ],
# 'name' => 'type check: must accept [[]]',
# 'schema' => 'array',
# 'tags' => [
# 'type',
# 'type:array'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:array) type check: must accept [[]]
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 3 - (tags=type, type:array) type check: must accept [[]]
# {
# 'input' => 1,
# 'name' => 'type check: must reject 1',
# 'schema' => 'array',
# 'tags' => [
# 'type',
# 'type:array'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:array) type check: must reject 1
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 4 - (tags=type, type:array) type check: must reject 1
# {
# 'input' => 'a',
# 'name' => 'type check: must reject a',
# 'schema' => 'array',
# 'tags' => [
# 'type',
# 'type:array'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:array) type check: must reject a
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 5 - (tags=type, type:array) type check: must reject a
# {
# 'input' => {},
# 'name' => 'type check: must reject {}',
# 'schema' => 'array',
# 'tags' => [
# 'type',
# 'type:array'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:array) type check: must reject {}
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 6 - (tags=type, type:array) type check: must reject {}
# {
# 'input' => undef,
# 'name' => 'must accept undefined value',
# 'schema' => 'array',
# 'tags' => [
# 'type',
# 'type:array'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:array) must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 7 - (tags=type, type:array) must accept undefined value
# {
# 'input' => undef,
# 'name' => 'defhash_v',
# 'schema' => [
# 'array',
# 'defhash_v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:defhash_v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:defhash_v, type, type:array) defhash_v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 8 - (tags=clause:defhash_v, type, type:array) defhash_v
# {
# 'input' => undef,
# 'name' => 'v',
# 'schema' => [
# 'array',
# 'v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:v, type, type:array) v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 9 - (tags=clause:v, type, type:array) v
# {
# 'input' => undef,
# 'name' => 'c',
# 'schema' => [
# 'array',
# 'c.foo.bar',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:c'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:c, type, type:array) c
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 10 - (tags=clause:c, type, type:array) c
# {
# 'input' => undef,
# 'name' => 'default_lang',
# 'schema' => [
# 'array',
# 'default_lang',
# 'id_ID'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:default_lang'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default_lang, type, type:array) default_lang
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 11 - (tags=clause:default_lang, type, type:array) default_lang
# {
# 'input' => undef,
# 'name' => 'name',
# 'schema' => [
# 'array',
# 'name',
# 'some name'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:name'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:name, type, type:array) name
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 12 - (tags=clause:name, type, type:array) name
# {
# 'input' => undef,
# 'name' => 'summary',
# 'schema' => [
# 'array',
# 'summary',
# 'some summary'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:summary'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:summary, type, type:array) summary
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 13 - (tags=clause:summary, type, type:array) summary
# {
# 'input' => undef,
# 'name' => 'description',
# 'schema' => [
# 'array',
# 'description',
# 'some description and `markdown`'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:description'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:description, type, type:array) description
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 14 - (tags=clause:description, type, type:array) description
# {
# 'input' => undef,
# 'name' => 'tags',
# 'schema' => [
# 'array',
# 'tags',
# [
# 'some',
# 'tags'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:tags'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:tags, type, type:array) tags
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 15 - (tags=clause:tags, type, type:array) tags
# {
# 'input' => undef,
# 'name' => 'req=0 must accept undefined value',
# 'schema' => [
# 'array',
# 'req',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:req'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req, type, type:array) req=0 must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 16 - (tags=clause:req, type, type:array) req=0 must accept undefined value
# {
# 'input' => undef,
# 'name' => 'req=1 must reject undefined value',
# 'schema' => [
# 'array',
# 'req',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:req'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:req, type, type:array) req=1 must reject undefined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 17 - (tags=clause:req, type, type:array) req=1 must reject undefined value
# {
# 'input' => [
# 1
# ],
# 'name' => 'forbidden=0 must accept defined value',
# 'schema' => [
# 'array',
# 'forbidden',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:forbidden'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden, type, type:array) forbidden=0 must accept defined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 18 - (tags=clause:forbidden, type, type:array) forbidden=0 must accept defined value
# {
# 'input' => [
# 1
# ],
# 'name' => 'forbidden=1 must reject defined value',
# 'schema' => [
# 'array',
# 'forbidden',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:forbidden'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:forbidden, type, type:array) forbidden=1 must reject defined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 19 - (tags=clause:forbidden, type, type:array) forbidden=1 must reject defined value
# {
# 'input' => undef,
# 'name' => 'default: must accept valid default []',
# 'schema' => [
# 'array*',
# 'default',
# []
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:default'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default, type, type:array) default: must accept valid default []
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 20 - (tags=clause:default, type, type:array) default: must accept valid default []
# {
# 'input' => undef,
# 'name' => 'default: must reject invalid default a',
# 'schema' => [
# 'array*',
# 'default',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:default'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:default, type, type:array) default: must reject invalid default a
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 21 - (tags=clause:default, type, type:array) default: must reject invalid default a
# {
# 'dies' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'clause (dies, unknown clause)',
# 'schema' => [
# 'array*',
# 'clause',
# [
# 'foo',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:clause'
# ]
# }
# Subtest: (tags=clause:clause, type, type:array) clause (dies, unknown clause)
ok 1 - compile error
1..1
ok 22 - (tags=clause:clause, type, type:array) clause (dies, unknown clause)
# {
# 'input' => [
# 1
# ],
# 'name' => 'clause (ok)',
# 'schema' => [
# 'array*',
# 'clause',
# [
# 'min_len',
# 0
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:clause'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clause, type, type:array) clause (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 23 - (tags=clause:clause, type, type:array) clause (ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'clause (ok) + clause nok = nok',
# 'schema' => [
# 'array*',
# 'clause',
# [
# 'min_len',
# 0
# ],
# 'max_len',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:array) clause (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 24 - (tags=clause:clause, type, type:array) clause (ok) + clause nok = nok
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'clause (nok)',
# 'schema' => [
# 'array*',
# 'clause',
# [
# 'min_len',
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:array) clause (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 25 - (tags=clause:clause, type, type:array) clause (nok)
# {
# 'dies' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'clset (dies, unknown clause)',
# 'schema' => [
# 'array*',
# 'clset',
# {
# 'foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:array) clset (dies, unknown clause)
ok 1 - compile error
1..1
ok 26 - (tags=clause:clset, type, type:array) clset (dies, unknown clause)
# {
# 'dies' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'clset (dies, unknown attr)',
# 'schema' => [
# 'array*',
# 'clset',
# {
# 'min_len' => 1,
# 'min_len.foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:array) clset (dies, unknown attr)
ok 1 - compile error
1..1
ok 27 - (tags=clause:clset, type, type:array) clset (dies, unknown attr)
# {
# 'input' => [
# 1
# ],
# 'name' => 'clset (empty = ok)',
# 'schema' => [
# 'array*',
# 'clset',
# {}
# ],
# 'tags' => [
# 'type',
# 'type:array'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:array) clset (empty = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 28 - (tags=type, type:array) clset (empty = ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'clset (ignored clause/attr = ok)',
# 'schema' => [
# 'array*',
# 'clset',
# {
# '_foo' => 1,
# 'foo._bar' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:array) clset (ignored clause/attr = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 29 - (tags=clause:clset, type, type:array) clset (ignored clause/attr = ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'clset (ok + ok = ok)',
# 'schema' => [
# 'array*',
# 'clset',
# {
# 'max_len' => 1,
# 'min_len' => 0
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:array) clset (ok + ok = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 30 - (tags=clause:clset, type, type:array) clset (ok + ok = ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'clset (ok) + clause nok = nok',
# 'schema' => [
# 'array*',
# 'clset',
# {
# 'min_len' => 0
# },
# 'max_len',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:array) clset (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 31 - (tags=clause:clset, type, type:array) clset (ok) + clause nok = nok
# {
# 'input' => [
# 1
# ],
# 'name' => 'clset (ok + nok = nok)',
# 'schema' => [
# 'array*',
# 'clset',
# {
# 'max_len' => 0,
# 'min_len' => 0
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:array) clset (ok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 32 - (tags=clause:clset, type, type:array) clset (ok + nok = nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'clset (nok + ok = nok)',
# 'schema' => [
# 'array*',
# 'clset',
# {
# 'max_len' => 1,
# 'min_len' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:array) clset (nok + ok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 33 - (tags=clause:clset, type, type:array) clset (nok + ok = nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'clset (nok + nok = nok)',
# 'schema' => [
# 'array*',
# 'clset',
# {
# 'max_len' => 0,
# 'min_len' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:array) clset (nok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 34 - (tags=clause:clset, type, type:array) clset (nok + nok = nok)
# {
# 'input' => undef,
# 'name' => 'ok',
# 'schema' => [
# 'array',
# {
# 'ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:ok'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:ok, type, type:array) ok
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 35 - (tags=clause:ok, type, type:array) ok
# {
# 'input' => undef,
# 'name' => 'ok + op not (nok)',
# 'schema' => [
# 'array',
# {
# '!ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:ok',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:ok, op, op:not, type, type:array) ok + op not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 36 - (tags=clause:ok, op, op:not, type, type:array) ok + op not (nok)
# {
# 'input' => [],
# 'name' => '.err_level=error (clause=is, ok)',
# 'schema' => [
# 'array',
# 'is',
# []
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:array) .err_level=error (clause=is, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 37 - (tags=attr, attr:err_level, type, type:array) .err_level=error (clause=is, ok)
# {
# 'input' => [
# 0
# ],
# 'name' => '.err_level=error (clause=is, nok)',
# 'schema' => [
# 'array',
# 'is',
# []
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 0
# }
# Subtest: (tags=attr, attr:err_level, type, type:array) .err_level=error (clause=is, nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 38 - (tags=attr, attr:err_level, type, type:array) .err_level=error (clause=is, nok)
# {
# 'input' => [],
# 'name' => '.err_level=warn (clause=is, ok)',
# 'schema' => [
# 'array',
# 'is',
# [],
# 'is.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:array) .err_level=warn (clause=is, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 39 - (tags=attr, attr:err_level, type, type:array) .err_level=warn (clause=is, ok)
# {
# 'input' => [
# 0
# ],
# 'name' => '.err_level=warn (clause=is, nok)',
# 'schema' => [
# 'array*',
# 'is',
# [],
# 'is.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1,
# 'warnings' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:array) .err_level=warn (clause=is, nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 40 - (tags=attr, attr:err_level, type, type:array) .err_level=warn (clause=is, nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is: must accept same value',
# 'schema' => [
# 'array',
# 'is',
# [
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, type, type:array) is: must accept same value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 41 - (tags=clause:is, type, type:array) is: must accept same value
# {
# 'input' => [
# 1
# ],
# 'name' => 'is: must reject different value',
# 'schema' => [
# 'array',
# 'is',
# [
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, type, type:array) is: must reject different value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 42 - (tags=clause:is, type, type:array) is: must reject different value
# {
# 'input' => [
# 1
# ],
# 'name' => '!is (nok)',
# 'schema' => [
# 'array',
# '!is',
# [
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:array) !is (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 43 - (tags=clause:is, op, op:not, opshortcut, type, type:array) !is (nok)
# {
# 'input' => [
# 1
# ],
# 'name' => '!is (ok)',
# 'schema' => [
# 'array',
# '!is',
# [
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:array) !is (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 44 - (tags=clause:is, op, op:not, opshortcut, type, type:array) !is (ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is.op=not (nok)',
# 'schema' => [
# 'array',
# 'is',
# [
# 1
# ],
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, type, type:array) is.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 45 - (tags=clause:is, op, op:not, type, type:array) is.op=not (nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is.op=not (ok)',
# 'schema' => [
# 'array',
# 'is',
# [
# 2
# ],
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, type, type:array) is.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 46 - (tags=clause:is, op, op:not, type, type:array) is.op=not (ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is& (no items)',
# 'schema' => [
# 'array',
# 'is&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:array) is& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 47 - (tags=clause:is, op, op:and, opshortcut, type, type:array) is& (no items)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is& (ok)',
# 'schema' => [
# 'array',
# 'is&',
# [
# [
# 1
# ],
# [
# 1
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:array) is& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 48 - (tags=clause:is, op, op:and, opshortcut, type, type:array) is& (ok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'is& (nok + ok)',
# 'schema' => [
# 'array',
# 'is&',
# [
# [
# 2
# ],
# [
# 1
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:array) is& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 49 - (tags=clause:is, op, op:and, opshortcut, type, type:array) is& (nok + ok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'is& (ok + nok)',
# 'schema' => [
# 'array',
# 'is&',
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:array) is& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 50 - (tags=clause:is, op, op:and, opshortcut, type, type:array) is& (ok + nok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'is& (nok + nok)',
# 'schema' => [
# 'array',
# 'is&',
# [
# [
# 2
# ],
# [
# 2
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:array) is& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 51 - (tags=clause:is, op, op:and, opshortcut, type, type:array) is& (nok + nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is.op=and (no items)',
# 'schema' => [
# 'array',
# 'is',
# [],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:array'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:array) is.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 52 - (tags=type, type:array) is.op=and (no items)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is.op=and (ok)',
# 'schema' => [
# 'array',
# 'is',
# [
# [
# 1
# ],
# [
# 1
# ]
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, type, type:array) is.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 53 - (tags=clause:is, op, op:and, type, type:array) is.op=and (ok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'is.op=and (nok + ok)',
# 'schema' => [
# 'array',
# 'is',
# [
# [
# 2
# ],
# [
# 1
# ]
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:array) is.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 54 - (tags=clause:is, op, op:and, type, type:array) is.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'is.op=and (ok + nok)',
# 'schema' => [
# 'array',
# 'is',
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:array) is.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 55 - (tags=clause:is, op, op:and, type, type:array) is.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'is.op=and (nok + nok)',
# 'schema' => [
# 'array',
# 'is',
# [
# [
# 2
# ],
# [
# 2
# ]
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:array) is.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 56 - (tags=clause:is, op, op:and, type, type:array) is.op=and (nok + nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is| (no items)',
# 'schema' => [
# 'array',
# 'is|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:array) is| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 57 - (tags=clause:is, op, op:or, opshortcut, type, type:array) is| (no items)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is| (ok)',
# 'schema' => [
# 'array',
# 'is|',
# [
# [
# 1
# ],
# [
# 1
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:array) is| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 58 - (tags=clause:is, op, op:or, opshortcut, type, type:array) is| (ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is| (nok + ok)',
# 'schema' => [
# 'array',
# 'is|',
# [
# [
# 2
# ],
# [
# 1
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:array) is| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 59 - (tags=clause:is, op, op:or, opshortcut, type, type:array) is| (nok + ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is| (ok + nok)',
# 'schema' => [
# 'array',
# 'is|',
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:array) is| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 60 - (tags=clause:is, op, op:or, opshortcut, type, type:array) is| (ok + nok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'is| (nok + nok)',
# 'schema' => [
# 'array',
# 'is|',
# [
# [
# 2
# ],
# [
# 2
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:array) is| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 61 - (tags=clause:is, op, op:or, opshortcut, type, type:array) is| (nok + nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is.op=or (no items)',
# 'schema' => [
# 'array',
# 'is',
# [],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:array) is.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 62 - (tags=clause:is, op, op:or, type, type:array) is.op=or (no items)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is.op=or (ok)',
# 'schema' => [
# 'array',
# 'is',
# [
# [
# 1
# ],
# [
# 1
# ]
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:array) is.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 63 - (tags=clause:is, op, op:or, type, type:array) is.op=or (ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is.op=or (nok + ok)',
# 'schema' => [
# 'array',
# 'is',
# [
# [
# 2
# ],
# [
# 1
# ]
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:array) is.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 64 - (tags=clause:is, op, op:or, type, type:array) is.op=or (nok + ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is.op=or (ok + nok)',
# 'schema' => [
# 'array',
# 'is',
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:array) is.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 65 - (tags=clause:is, op, op:or, type, type:array) is.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'is.op=or (nok + nok)',
# 'schema' => [
# 'array',
# 'is',
# [
# [
# 2
# ],
# [
# 2
# ]
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, type, type:array) is.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 66 - (tags=clause:is, op, op:or, type, type:array) is.op=or (nok + nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is.op=none (empty items)',
# 'schema' => [
# 'array',
# 'is',
# [],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:array) is.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 67 - (tags=clause:is, op, op:none, type, type:array) is.op=none (empty items)
# {
# 'input' => [
# 1
# ],
# 'name' => 'is.op=none (nok + nok)',
# 'schema' => [
# 'array',
# 'is',
# [
# [
# 2
# ],
# [
# 2
# ]
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:array) is.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 68 - (tags=clause:is, op, op:none, type, type:array) is.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'is.op=none (nok + ok)',
# 'schema' => [
# 'array',
# 'is',
# [
# [
# 2
# ],
# [
# 1
# ]
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:array) is.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 69 - (tags=clause:is, op, op:none, type, type:array) is.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'is.op=none (ok + nok)',
# 'schema' => [
# 'array',
# 'is',
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:array) is.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 70 - (tags=clause:is, op, op:none, type, type:array) is.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'is.op=none (ok + ok)',
# 'schema' => [
# 'array',
# 'is',
# [
# [
# 1
# ],
# [
# 1
# ]
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:array) is.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 71 - (tags=clause:is, op, op:none, type, type:array) is.op=none (ok + ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in: must accept valid choices',
# 'schema' => [
# 'array',
# 'in',
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, type, type:array) in: must accept valid choices
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 72 - (tags=clause:in, type, type:array) in: must accept valid choices
# {
# 'input' => [
# 1
# ],
# 'name' => 'in: must reject empty choices',
# 'schema' => [
# 'array',
# 'in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, type, type:array) in: must reject empty choices
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 73 - (tags=clause:in, type, type:array) in: must reject empty choices
# {
# 'input' => [
# 1
# ],
# 'name' => '!in (nok)',
# 'schema' => [
# 'array',
# '!in',
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:array) !in (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 74 - (tags=clause:in, op, op:not, opshortcut, type, type:array) !in (nok)
# {
# 'input' => [
# 1
# ],
# 'name' => '!in (ok)',
# 'schema' => [
# 'array',
# '!in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:array) !in (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 75 - (tags=clause:in, op, op:not, opshortcut, type, type:array) !in (ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in.op=not (nok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, type, type:array) in.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 76 - (tags=clause:in, op, op:not, type, type:array) in.op=not (nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in.op=not (ok)',
# 'schema' => [
# 'array',
# 'in',
# [],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, type, type:array) in.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 77 - (tags=clause:in, op, op:not, type, type:array) in.op=not (ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in& (no items)',
# 'schema' => [
# 'array',
# 'in&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:array) in& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 78 - (tags=clause:in, op, op:and, opshortcut, type, type:array) in& (no items)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in& (ok)',
# 'schema' => [
# 'array',
# 'in&',
# [
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:array) in& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 79 - (tags=clause:in, op, op:and, opshortcut, type, type:array) in& (ok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'in& (nok + ok)',
# 'schema' => [
# 'array',
# 'in&',
# [
# [],
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:array) in& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 80 - (tags=clause:in, op, op:and, opshortcut, type, type:array) in& (nok + ok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'in& (ok + nok)',
# 'schema' => [
# 'array',
# 'in&',
# [
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:array) in& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 81 - (tags=clause:in, op, op:and, opshortcut, type, type:array) in& (ok + nok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'in& (nok + nok)',
# 'schema' => [
# 'array',
# 'in&',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:array) in& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 82 - (tags=clause:in, op, op:and, opshortcut, type, type:array) in& (nok + nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in.op=and (no items)',
# 'schema' => [
# 'array',
# 'in',
# [],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:array'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:array) in.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 83 - (tags=type, type:array) in.op=and (no items)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in.op=and (ok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, type, type:array) in.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 84 - (tags=clause:in, op, op:and, type, type:array) in.op=and (ok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'in.op=and (nok + ok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [],
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:array) in.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 85 - (tags=clause:in, op, op:and, type, type:array) in.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'in.op=and (ok + nok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:array) in.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 86 - (tags=clause:in, op, op:and, type, type:array) in.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'in.op=and (nok + nok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:array) in.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 87 - (tags=clause:in, op, op:and, type, type:array) in.op=and (nok + nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in| (no items)',
# 'schema' => [
# 'array',
# 'in|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:array) in| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 88 - (tags=clause:in, op, op:or, opshortcut, type, type:array) in| (no items)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in| (ok)',
# 'schema' => [
# 'array',
# 'in|',
# [
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:array) in| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 89 - (tags=clause:in, op, op:or, opshortcut, type, type:array) in| (ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in| (nok + ok)',
# 'schema' => [
# 'array',
# 'in|',
# [
# [],
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:array) in| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 90 - (tags=clause:in, op, op:or, opshortcut, type, type:array) in| (nok + ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in| (ok + nok)',
# 'schema' => [
# 'array',
# 'in|',
# [
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:array) in| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 91 - (tags=clause:in, op, op:or, opshortcut, type, type:array) in| (ok + nok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'in| (nok + nok)',
# 'schema' => [
# 'array',
# 'in|',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:array) in| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 92 - (tags=clause:in, op, op:or, opshortcut, type, type:array) in| (nok + nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in.op=or (no items)',
# 'schema' => [
# 'array',
# 'in',
# [],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:array) in.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 93 - (tags=clause:in, op, op:or, type, type:array) in.op=or (no items)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in.op=or (ok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:array) in.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 94 - (tags=clause:in, op, op:or, type, type:array) in.op=or (ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in.op=or (nok + ok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [],
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:array) in.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 95 - (tags=clause:in, op, op:or, type, type:array) in.op=or (nok + ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in.op=or (ok + nok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:array) in.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 96 - (tags=clause:in, op, op:or, type, type:array) in.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'in.op=or (nok + nok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, type, type:array) in.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 97 - (tags=clause:in, op, op:or, type, type:array) in.op=or (nok + nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in.op=none (empty items)',
# 'schema' => [
# 'array',
# 'in',
# [],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:array) in.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 98 - (tags=clause:in, op, op:none, type, type:array) in.op=none (empty items)
# {
# 'input' => [
# 1
# ],
# 'name' => 'in.op=none (nok + nok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:array) in.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 99 - (tags=clause:in, op, op:none, type, type:array) in.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'in.op=none (nok + ok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [],
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:array) in.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 100 - (tags=clause:in, op, op:none, type, type:array) in.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'in.op=none (ok + nok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:array) in.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 101 - (tags=clause:in, op, op:none, type, type:array) in.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => [
# 1
# ],
# 'name' => 'in.op=none (ok + ok)',
# 'schema' => [
# 'array',
# 'in',
# [
# [
# [
# 1
# ],
# [
# 2
# ]
# ],
# [
# [
# 1
# ],
# [
# 2
# ]
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:array) in.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 102 - (tags=clause:in, op, op:none, type, type:array) in.op=none (ok + ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'len (ok)',
# 'schema' => [
# 'array',
# 'len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:len, type, type:array) len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 103 - (tags=clause:len, type, type:array) len (ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'len (nok)',
# 'schema' => [
# 'array',
# 'len',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:len, type, type:array) len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 104 - (tags=clause:len, type, type:array) len (nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'min_len (ok)',
# 'schema' => [
# 'array',
# 'min_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:min_len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min_len, type, type:array) min_len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 105 - (tags=clause:min_len, type, type:array) min_len (ok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'min_len (nok)',
# 'schema' => [
# 'array',
# 'min_len',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:min_len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:min_len, type, type:array) min_len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 106 - (tags=clause:min_len, type, type:array) min_len (nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'max_len (ok)',
# 'schema' => [
# 'array',
# 'min_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:max_len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max_len, type, type:array) max_len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 107 - (tags=clause:max_len, type, type:array) max_len (ok)
# {
# 'input' => [
# 1,
# '1.2'
# ],
# 'name' => 'max_len (nok)',
# 'schema' => [
# 'array',
# 'max_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:max_len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:max_len, type, type:array) max_len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 108 - (tags=clause:max_len, type, type:array) max_len (nok)
# {
# 'input' => [
# 1
# ],
# 'name' => 'len_between (ok)',
# 'schema' => [
# 'array',
# 'len_between',
# [
# 1,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:len_between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:len_between, type, type:array) len_between (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 109 - (tags=clause:len_between, type, type:array) len_between (ok)
# {
# 'input' => [
# 1,
# '1.2'
# ],
# 'name' => 'len_between (nok)',
# 'schema' => [
# 'array',
# 'len_between',
# [
# 1,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:len_between'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:len_between, type, type:array) len_between (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 110 - (tags=clause:len_between, type, type:array) len_between (nok)
# {
# 'input' => [
# 1,
# '1.2'
# ],
# 'name' => 'each_index (ok)',
# 'schema' => [
# 'array',
# 'each_index',
# [
# 'int',
# 'max',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:each_index'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:each_index, type, type:array) each_index (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 111 - (tags=clause:each_index, type, type:array) each_index (ok)
# {
# 'input' => [
# 1,
# '1.2'
# ],
# 'name' => 'each_index (nok)',
# 'schema' => [
# 'array',
# 'each_index',
# [
# 'int',
# 'xmax',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:each_index'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:each_index, type, type:array) each_index (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 112 - (tags=clause:each_index, type, type:array) each_index (nok)
# {
# 'input' => [
# 1,
# '1.2'
# ],
# 'name' => 'each_elem (ok)',
# 'schema' => [
# 'array',
# 'each_elem',
# 'float'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:each_elem'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:each_elem, type, type:array) each_elem (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 113 - (tags=clause:each_elem, type, type:array) each_elem (ok)
# {
# 'input' => [
# 1,
# '1.2'
# ],
# 'name' => 'each_elem (nok)',
# 'schema' => [
# 'array',
# 'each_elem',
# 'int'
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:each_elem'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:each_elem, type, type:array) each_elem (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 114 - (tags=clause:each_elem, type, type:array) each_elem (nok)
# {
# 'input' => [
# 1,
# '1.2'
# ],
# 'name' => 'elems (ok)',
# 'schema' => [
# 'array',
# 'elems',
# [
# 'int',
# 'float'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:elems'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:elems, type, type:array) elems (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 115 - (tags=clause:elems, type, type:array) elems (ok)
# {
# 'input' => [
# 1,
# '1.2'
# ],
# 'name' => 'elems (nok)',
# 'schema' => [
# 'array',
# 'elems',
# [
# 'int',
# 'int'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:elems'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:elems, type, type:array) elems (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 116 - (tags=clause:elems, type, type:array) elems (nok)
# {
# 'invalid_inputs' => [
# [],
# [
# 3
# ]
# ],
# 'name' => 'has',
# 'schema' => [
# 'array',
# 'has',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:has'
# ],
# 'valid_inputs' => [
# [
# 1,
# 2,
# 3
# ],
# [
# 1,
# 3
# ]
# ]
# }
# Subtest: (tags=clause:has, type, type:array) has
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - validator (rt=full) returns hash
1..6
ok 117 - (tags=clause:has, type, type:array) has
# {
# 'invalid_inputs' => [
# [
# 1,
# 2,
# 3
# ],
# [
# 1,
# 3
# ]
# ],
# 'name' => 'has + op.not',
# 'schema' => [
# 'array',
# '!has',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:has',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# [],
# [
# 3
# ]
# ]
# }
# Subtest: (tags=clause:has, op, op:not, opshortcut, type, type:array) has + op.not
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - validator (rt=full) returns hash
1..6
ok 118 - (tags=clause:has, op, op:not, opshortcut, type, type:array) has + op.not
# {
# 'invalid_inputs' => [
# [],
# [
# 3
# ]
# ],
# 'name' => 'has + op.or',
# 'schema' => [
# 'array',
# 'has|',
# [
# 1,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:has',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# [
# 1,
# 2,
# 3
# ],
# [
# 1,
# 3
# ]
# ]
# }
# Subtest: (tags=clause:has, op, op:or, opshortcut, type, type:array) has + op.or
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - validator (rt=full) returns hash
1..6
ok 119 - (tags=clause:has, op, op:or, opshortcut, type, type:array) has + op.or
# {
# 'invalid_inputs' => [
# [
# 1,
# 3
# ],
# [],
# [
# 3
# ]
# ],
# 'name' => 'has + op.and',
# 'schema' => [
# 'array',
# 'has&',
# [
# 1,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:has',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# [
# 1,
# 2,
# 3
# ]
# ]
# }
# Subtest: (tags=clause:has, op, op:and, opshortcut, type, type:array) has + op.and
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - invalid input [0]
ok 4 - invalid input [1]
ok 5 - invalid input [2]
ok 6 - validator (rt=full) returns hash
1..6
ok 120 - (tags=clause:has, op, op:and, opshortcut, type, type:array) has + op.and
# {
# 'input' => [
# undef,
# 1
# ],
# 'name' => 'elems (nok, first elem required)',
# 'schema' => [
# 'array',
# {
# 'elems' => [
# 'int*',
# [
# 'float',
# 'default',
# 2
# ]
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:elems'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:elems, type, type:array) elems (nok, first elem required)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 121 - (tags=clause:elems, type, type:array) elems (nok, first elem required)
# {
# 'input' => [
# 1
# ],
# 'name' => 'elems (ok, missing elem set to undef)',
# 'schema' => [
# 'array',
# {
# 'elems' => [
# 'int*',
# [
# 'float',
# 'default',
# 2
# ]
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:elems'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:elems, type, type:array) elems (ok, missing elem set to undef)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 122 - (tags=clause:elems, type, type:array) elems (ok, missing elem set to undef)
# {
# 'input' => [
# 1,
# undef
# ],
# 'name' => 'elems (ok, second elem optional)',
# 'schema' => [
# 'array',
# {
# 'elems' => [
# 'int*',
# [
# 'float',
# 'default',
# 2
# ]
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:elems'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:elems, type, type:array) elems (ok, second elem optional)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 123 - (tags=clause:elems, type, type:array) elems (ok, second elem optional)
# {
# 'input' => [
# 1,
# '1.1'
# ],
# 'name' => 'elems (ok 2)',
# 'schema' => [
# 'array',
# {
# 'elems' => [
# 'int*',
# [
# 'float',
# 'default',
# 2
# ]
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:elems'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:elems, type, type:array) elems (ok 2)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 124 - (tags=clause:elems, type, type:array) elems (ok 2)
# {
# 'input' => [
# 1,
# '1.1',
# undef
# ],
# 'name' => 'elems (ok, extra elems ignored)',
# 'schema' => [
# 'array',
# {
# 'elems' => [
# 'int*',
# [
# 'float',
# 'default',
# 2
# ]
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:elems'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:elems, type, type:array) elems (ok, extra elems ignored)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 125 - (tags=clause:elems, type, type:array) elems (ok, extra elems ignored)
# {
# 'input' => [
# 1,
# '1.1',
# 'foo'
# ],
# 'name' => 'elems (ok, extra elems ignored 2)',
# 'schema' => [
# 'array',
# {
# 'elems' => [
# 'int*',
# [
# 'float',
# 'default',
# 2
# ]
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:elems'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:elems, type, type:array) elems (ok, extra elems ignored 2)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 126 - (tags=clause:elems, type, type:array) elems (ok, extra elems ignored 2)
# {
# 'input' => [
# 1
# ],
# 'name' => 'elems (ok, create_default=0)',
# 'output' => [
# 1
# ],
# 'schema' => [
# 'array',
# {
# 'elems' => [
# 'int',
# [
# 'int',
# 'default',
# 2
# ]
# ],
# 'elems.create_default' => 0
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:elems'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:elems, type, type:array) elems (ok, create_default=0)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - output
ok 4 - valid (rt=str)
ok 5 - validator (rt=full) returns hash
ok 6 - errors (rt=full)
ok 7 - warnings (rt=full)
1..7
ok 127 - (tags=clause:elems, type, type:array) elems (ok, create_default=0)
# {
# 'input' => [
# 1,
# undef
# ],
# 'name' => 'elems (ok 2, create_default=0)',
# 'output' => [
# 1,
# 2
# ],
# 'schema' => [
# 'array',
# {
# 'elems' => [
# 'int',
# [
# 'int',
# 'default',
# 2
# ]
# ],
# 'elems.create_default' => 0
# }
# ],
# 'tags' => [
# 'type',
# 'type:array',
# 'clause:elems'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:elems, type, type:array) elems (ok 2, create_default=0)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - output
ok 4 - valid (rt=str)
ok 5 - validator (rt=full) returns hash
ok 6 - errors (rt=full)
ok 7 - warnings (rt=full)
1..7
ok 128 - (tags=clause:elems, type, type:array) elems (ok 2, create_default=0)
ok 129
1..129
ok 5 - 10-type-array.json
# Subtest: 10-type-bool.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => 0,
# 'name' => 'type check: must accept 0',
# 'schema' => 'bool',
# 'tags' => [
# 'type',
# 'type:bool'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:bool) type check: must accept 0
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=type, type:bool) type check: must accept 0
# {
# 'input' => 1,
# 'name' => 'type check: must accept 1',
# 'schema' => 'bool',
# 'tags' => [
# 'type',
# 'type:bool'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:bool) type check: must accept 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=type, type:bool) type check: must accept 1
# {
# 'input' => [],
# 'name' => 'type check: must reject []',
# 'schema' => 'bool',
# 'tags' => [
# 'type',
# 'type:bool'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:bool) type check: must reject []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 3 - (tags=type, type:bool) type check: must reject []
# {
# 'input' => {},
# 'name' => 'type check: must reject {}',
# 'schema' => 'bool',
# 'tags' => [
# 'type',
# 'type:bool'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:bool) type check: must reject {}
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 4 - (tags=type, type:bool) type check: must reject {}
# {
# 'input' => undef,
# 'name' => 'must accept undefined value',
# 'schema' => 'bool',
# 'tags' => [
# 'type',
# 'type:bool'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:bool) must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 5 - (tags=type, type:bool) must accept undefined value
# {
# 'input' => undef,
# 'name' => 'defhash_v',
# 'schema' => [
# 'bool',
# 'defhash_v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:defhash_v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:defhash_v, type, type:bool) defhash_v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 6 - (tags=clause:defhash_v, type, type:bool) defhash_v
# {
# 'input' => undef,
# 'name' => 'v',
# 'schema' => [
# 'bool',
# 'v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:v, type, type:bool) v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 7 - (tags=clause:v, type, type:bool) v
# {
# 'input' => undef,
# 'name' => 'c',
# 'schema' => [
# 'bool',
# 'c.foo.bar',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:c'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:c, type, type:bool) c
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 8 - (tags=clause:c, type, type:bool) c
# {
# 'input' => undef,
# 'name' => 'default_lang',
# 'schema' => [
# 'bool',
# 'default_lang',
# 'id_ID'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:default_lang'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default_lang, type, type:bool) default_lang
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 9 - (tags=clause:default_lang, type, type:bool) default_lang
# {
# 'input' => undef,
# 'name' => 'name',
# 'schema' => [
# 'bool',
# 'name',
# 'some name'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:name'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:name, type, type:bool) name
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 10 - (tags=clause:name, type, type:bool) name
# {
# 'input' => undef,
# 'name' => 'summary',
# 'schema' => [
# 'bool',
# 'summary',
# 'some summary'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:summary'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:summary, type, type:bool) summary
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 11 - (tags=clause:summary, type, type:bool) summary
# {
# 'input' => undef,
# 'name' => 'description',
# 'schema' => [
# 'bool',
# 'description',
# 'some description and `markdown`'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:description'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:description, type, type:bool) description
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 12 - (tags=clause:description, type, type:bool) description
# {
# 'input' => undef,
# 'name' => 'tags',
# 'schema' => [
# 'bool',
# 'tags',
# [
# 'some',
# 'tags'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:tags'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:tags, type, type:bool) tags
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 13 - (tags=clause:tags, type, type:bool) tags
# {
# 'input' => undef,
# 'name' => 'req=0 must accept undefined value',
# 'schema' => [
# 'bool',
# 'req',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:req'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req, type, type:bool) req=0 must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 14 - (tags=clause:req, type, type:bool) req=0 must accept undefined value
# {
# 'input' => undef,
# 'name' => 'req=1 must reject undefined value',
# 'schema' => [
# 'bool',
# 'req',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:req'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:req, type, type:bool) req=1 must reject undefined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 15 - (tags=clause:req, type, type:bool) req=1 must reject undefined value
# {
# 'input' => 1,
# 'name' => 'forbidden=0 must accept defined value',
# 'schema' => [
# 'bool',
# 'forbidden',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:forbidden'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden, type, type:bool) forbidden=0 must accept defined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 16 - (tags=clause:forbidden, type, type:bool) forbidden=0 must accept defined value
# {
# 'input' => 1,
# 'name' => 'forbidden=1 must reject defined value',
# 'schema' => [
# 'bool',
# 'forbidden',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:forbidden'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:forbidden, type, type:bool) forbidden=1 must reject defined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 17 - (tags=clause:forbidden, type, type:bool) forbidden=1 must reject defined value
# {
# 'input' => undef,
# 'name' => 'default: must accept valid default 1',
# 'schema' => [
# 'bool*',
# 'default',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:default'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default, type, type:bool) default: must accept valid default 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 18 - (tags=clause:default, type, type:bool) default: must accept valid default 1
# {
# 'input' => undef,
# 'name' => 'default: must reject invalid default []',
# 'schema' => [
# 'bool*',
# 'default',
# []
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:default'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:default, type, type:bool) default: must reject invalid default []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 19 - (tags=clause:default, type, type:bool) default: must reject invalid default []
# {
# 'dies' => 1,
# 'input' => 1,
# 'name' => 'clause (dies, unknown clause)',
# 'schema' => [
# 'bool*',
# 'clause',
# [
# 'foo',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:clause'
# ]
# }
# Subtest: (tags=clause:clause, type, type:bool) clause (dies, unknown clause)
ok 1 - compile error
1..1
ok 20 - (tags=clause:clause, type, type:bool) clause (dies, unknown clause)
# {
# 'dies' => 1,
# 'input' => 1,
# 'name' => 'clset (dies, unknown clause)',
# 'schema' => [
# 'bool*',
# 'clset',
# {
# 'foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:bool) clset (dies, unknown clause)
ok 1 - compile error
1..1
ok 21 - (tags=clause:clset, type, type:bool) clset (dies, unknown clause)
# {
# 'dies' => 1,
# 'input' => 1,
# 'name' => 'clset (dies, unknown attr)',
# 'schema' => [
# 'bool*',
# 'clset',
# {
# 'min_len' => 1,
# 'min_len.foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:bool) clset (dies, unknown attr)
ok 1 - compile error
1..1
ok 22 - (tags=clause:clset, type, type:bool) clset (dies, unknown attr)
# {
# 'input' => 1,
# 'name' => 'clset (empty = ok)',
# 'schema' => [
# 'bool*',
# 'clset',
# {}
# ],
# 'tags' => [
# 'type',
# 'type:bool'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:bool) clset (empty = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 23 - (tags=type, type:bool) clset (empty = ok)
# {
# 'input' => 1,
# 'name' => 'clset (ignored clause/attr = ok)',
# 'schema' => [
# 'bool*',
# 'clset',
# {
# '_foo' => 1,
# 'foo._bar' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:bool) clset (ignored clause/attr = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 24 - (tags=clause:clset, type, type:bool) clset (ignored clause/attr = ok)
# {
# 'input' => undef,
# 'name' => 'ok',
# 'schema' => [
# 'bool',
# {
# 'ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:ok'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:ok, type, type:bool) ok
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 25 - (tags=clause:ok, type, type:bool) ok
# {
# 'input' => undef,
# 'name' => 'ok + op not (nok)',
# 'schema' => [
# 'bool',
# {
# '!ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:ok',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:ok, op, op:not, type, type:bool) ok + op not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 26 - (tags=clause:ok, op, op:not, type, type:bool) ok + op not (nok)
# {
# 'input' => 1,
# 'name' => '.err_level=error (clause=is, ok)',
# 'schema' => [
# 'bool',
# 'is',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:bool) .err_level=error (clause=is, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 27 - (tags=attr, attr:err_level, type, type:bool) .err_level=error (clause=is, ok)
# {
# 'input' => 0,
# 'name' => '.err_level=error (clause=is, nok)',
# 'schema' => [
# 'bool',
# 'is',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 0
# }
# Subtest: (tags=attr, attr:err_level, type, type:bool) .err_level=error (clause=is, nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 28 - (tags=attr, attr:err_level, type, type:bool) .err_level=error (clause=is, nok)
# {
# 'input' => 1,
# 'name' => '.err_level=warn (clause=is, ok)',
# 'schema' => [
# 'bool',
# 'is',
# 1,
# 'is.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:bool) .err_level=warn (clause=is, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 29 - (tags=attr, attr:err_level, type, type:bool) .err_level=warn (clause=is, ok)
# {
# 'input' => 0,
# 'name' => '.err_level=warn (clause=is, nok)',
# 'schema' => [
# 'bool*',
# 'is',
# 1,
# 'is.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1,
# 'warnings' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:bool) .err_level=warn (clause=is, nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 30 - (tags=attr, attr:err_level, type, type:bool) .err_level=warn (clause=is, nok)
# {
# 'input' => 0,
# 'name' => 'is: must accept same value',
# 'schema' => [
# 'bool',
# 'is',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, type, type:bool) is: must accept same value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 31 - (tags=clause:is, type, type:bool) is: must accept same value
# {
# 'input' => 0,
# 'name' => 'is: must reject different value',
# 'schema' => [
# 'bool',
# 'is',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, type, type:bool) is: must reject different value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 32 - (tags=clause:is, type, type:bool) is: must reject different value
# {
# 'input' => 0,
# 'name' => '!is (nok)',
# 'schema' => [
# 'bool',
# '!is',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:bool) !is (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 33 - (tags=clause:is, op, op:not, opshortcut, type, type:bool) !is (nok)
# {
# 'input' => 0,
# 'name' => '!is (ok)',
# 'schema' => [
# 'bool',
# '!is',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:bool) !is (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 34 - (tags=clause:is, op, op:not, opshortcut, type, type:bool) !is (ok)
# {
# 'input' => 0,
# 'name' => 'is.op=not (nok)',
# 'schema' => [
# 'bool',
# 'is',
# 0,
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, type, type:bool) is.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 35 - (tags=clause:is, op, op:not, type, type:bool) is.op=not (nok)
# {
# 'input' => 0,
# 'name' => 'is.op=not (ok)',
# 'schema' => [
# 'bool',
# 'is',
# 1,
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, type, type:bool) is.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 36 - (tags=clause:is, op, op:not, type, type:bool) is.op=not (ok)
# {
# 'input' => 0,
# 'name' => 'is& (no items)',
# 'schema' => [
# 'bool',
# 'is&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:bool) is& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 37 - (tags=clause:is, op, op:and, opshortcut, type, type:bool) is& (no items)
# {
# 'input' => 0,
# 'name' => 'is& (ok)',
# 'schema' => [
# 'bool',
# 'is&',
# [
# 0,
# 0
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:bool) is& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 38 - (tags=clause:is, op, op:and, opshortcut, type, type:bool) is& (ok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'is& (nok + ok)',
# 'schema' => [
# 'bool',
# 'is&',
# [
# 1,
# 0
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:bool) is& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 39 - (tags=clause:is, op, op:and, opshortcut, type, type:bool) is& (nok + ok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'is& (ok + nok)',
# 'schema' => [
# 'bool',
# 'is&',
# [
# 0,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:bool) is& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 40 - (tags=clause:is, op, op:and, opshortcut, type, type:bool) is& (ok + nok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'is& (nok + nok)',
# 'schema' => [
# 'bool',
# 'is&',
# [
# 1,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:bool) is& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 41 - (tags=clause:is, op, op:and, opshortcut, type, type:bool) is& (nok + nok)
# {
# 'input' => 0,
# 'name' => 'is.op=and (no items)',
# 'schema' => [
# 'bool',
# 'is',
# [],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:bool'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:bool) is.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 42 - (tags=type, type:bool) is.op=and (no items)
# {
# 'input' => 0,
# 'name' => 'is.op=and (ok)',
# 'schema' => [
# 'bool',
# 'is',
# [
# 0,
# 0
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, type, type:bool) is.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 43 - (tags=clause:is, op, op:and, type, type:bool) is.op=and (ok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'is.op=and (nok + ok)',
# 'schema' => [
# 'bool',
# 'is',
# [
# 1,
# 0
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:bool) is.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 44 - (tags=clause:is, op, op:and, type, type:bool) is.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'is.op=and (ok + nok)',
# 'schema' => [
# 'bool',
# 'is',
# [
# 0,
# 1
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:bool) is.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 45 - (tags=clause:is, op, op:and, type, type:bool) is.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'is.op=and (nok + nok)',
# 'schema' => [
# 'bool',
# 'is',
# [
# 1,
# 1
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:bool) is.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 46 - (tags=clause:is, op, op:and, type, type:bool) is.op=and (nok + nok)
# {
# 'input' => 0,
# 'name' => 'is| (no items)',
# 'schema' => [
# 'bool',
# 'is|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:bool) is| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 47 - (tags=clause:is, op, op:or, opshortcut, type, type:bool) is| (no items)
# {
# 'input' => 0,
# 'name' => 'is| (ok)',
# 'schema' => [
# 'bool',
# 'is|',
# [
# 0,
# 0
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:bool) is| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 48 - (tags=clause:is, op, op:or, opshortcut, type, type:bool) is| (ok)
# {
# 'input' => 0,
# 'name' => 'is| (nok + ok)',
# 'schema' => [
# 'bool',
# 'is|',
# [
# 1,
# 0
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:bool) is| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 49 - (tags=clause:is, op, op:or, opshortcut, type, type:bool) is| (nok + ok)
# {
# 'input' => 0,
# 'name' => 'is| (ok + nok)',
# 'schema' => [
# 'bool',
# 'is|',
# [
# 0,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:bool) is| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 50 - (tags=clause:is, op, op:or, opshortcut, type, type:bool) is| (ok + nok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'is| (nok + nok)',
# 'schema' => [
# 'bool',
# 'is|',
# [
# 1,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:bool) is| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 51 - (tags=clause:is, op, op:or, opshortcut, type, type:bool) is| (nok + nok)
# {
# 'input' => 0,
# 'name' => 'is.op=or (no items)',
# 'schema' => [
# 'bool',
# 'is',
# [],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:bool) is.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 52 - (tags=clause:is, op, op:or, type, type:bool) is.op=or (no items)
# {
# 'input' => 0,
# 'name' => 'is.op=or (ok)',
# 'schema' => [
# 'bool',
# 'is',
# [
# 0,
# 0
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:bool) is.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 53 - (tags=clause:is, op, op:or, type, type:bool) is.op=or (ok)
# {
# 'input' => 0,
# 'name' => 'is.op=or (nok + ok)',
# 'schema' => [
# 'bool',
# 'is',
# [
# 1,
# 0
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:bool) is.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 54 - (tags=clause:is, op, op:or, type, type:bool) is.op=or (nok + ok)
# {
# 'input' => 0,
# 'name' => 'is.op=or (ok + nok)',
# 'schema' => [
# 'bool',
# 'is',
# [
# 0,
# 1
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:bool) is.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 55 - (tags=clause:is, op, op:or, type, type:bool) is.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'is.op=or (nok + nok)',
# 'schema' => [
# 'bool',
# 'is',
# [
# 1,
# 1
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, type, type:bool) is.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 56 - (tags=clause:is, op, op:or, type, type:bool) is.op=or (nok + nok)
# {
# 'input' => 0,
# 'name' => 'is.op=none (empty items)',
# 'schema' => [
# 'bool',
# 'is',
# [],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:bool) is.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 57 - (tags=clause:is, op, op:none, type, type:bool) is.op=none (empty items)
# {
# 'input' => 0,
# 'name' => 'is.op=none (nok + nok)',
# 'schema' => [
# 'bool',
# 'is',
# [
# 1,
# 1
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:bool) is.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 58 - (tags=clause:is, op, op:none, type, type:bool) is.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'is.op=none (nok + ok)',
# 'schema' => [
# 'bool',
# 'is',
# [
# 1,
# 0
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:bool) is.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 59 - (tags=clause:is, op, op:none, type, type:bool) is.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'is.op=none (ok + nok)',
# 'schema' => [
# 'bool',
# 'is',
# [
# 0,
# 1
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:bool) is.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 60 - (tags=clause:is, op, op:none, type, type:bool) is.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'is.op=none (ok + ok)',
# 'schema' => [
# 'bool',
# 'is',
# [
# 0,
# 0
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:bool) is.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 61 - (tags=clause:is, op, op:none, type, type:bool) is.op=none (ok + ok)
# {
# 'input' => 0,
# 'name' => 'in: must accept valid choices',
# 'schema' => [
# 'bool',
# 'in',
# [
# 0,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, type, type:bool) in: must accept valid choices
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 62 - (tags=clause:in, type, type:bool) in: must accept valid choices
# {
# 'input' => 0,
# 'name' => 'in: must reject empty choices',
# 'schema' => [
# 'bool',
# 'in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, type, type:bool) in: must reject empty choices
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 63 - (tags=clause:in, type, type:bool) in: must reject empty choices
# {
# 'input' => 0,
# 'name' => '!in (nok)',
# 'schema' => [
# 'bool',
# '!in',
# [
# 0,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:bool) !in (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 64 - (tags=clause:in, op, op:not, opshortcut, type, type:bool) !in (nok)
# {
# 'input' => 0,
# 'name' => '!in (ok)',
# 'schema' => [
# 'bool',
# '!in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:bool) !in (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 65 - (tags=clause:in, op, op:not, opshortcut, type, type:bool) !in (ok)
# {
# 'input' => 0,
# 'name' => 'in.op=not (nok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# 0,
# 1
# ],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, type, type:bool) in.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 66 - (tags=clause:in, op, op:not, type, type:bool) in.op=not (nok)
# {
# 'input' => 0,
# 'name' => 'in.op=not (ok)',
# 'schema' => [
# 'bool',
# 'in',
# [],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, type, type:bool) in.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 67 - (tags=clause:in, op, op:not, type, type:bool) in.op=not (ok)
# {
# 'input' => 0,
# 'name' => 'in& (no items)',
# 'schema' => [
# 'bool',
# 'in&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:bool) in& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 68 - (tags=clause:in, op, op:and, opshortcut, type, type:bool) in& (no items)
# {
# 'input' => 0,
# 'name' => 'in& (ok)',
# 'schema' => [
# 'bool',
# 'in&',
# [
# [
# 0,
# 1
# ],
# [
# 0,
# 1
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:bool) in& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 69 - (tags=clause:in, op, op:and, opshortcut, type, type:bool) in& (ok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'in& (nok + ok)',
# 'schema' => [
# 'bool',
# 'in&',
# [
# [],
# [
# 0,
# 1
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:bool) in& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 70 - (tags=clause:in, op, op:and, opshortcut, type, type:bool) in& (nok + ok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'in& (ok + nok)',
# 'schema' => [
# 'bool',
# 'in&',
# [
# [
# 0,
# 1
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:bool) in& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 71 - (tags=clause:in, op, op:and, opshortcut, type, type:bool) in& (ok + nok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'in& (nok + nok)',
# 'schema' => [
# 'bool',
# 'in&',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:bool) in& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 72 - (tags=clause:in, op, op:and, opshortcut, type, type:bool) in& (nok + nok)
# {
# 'input' => 0,
# 'name' => 'in.op=and (no items)',
# 'schema' => [
# 'bool',
# 'in',
# [],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:bool'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:bool) in.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 73 - (tags=type, type:bool) in.op=and (no items)
# {
# 'input' => 0,
# 'name' => 'in.op=and (ok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# [
# 0,
# 1
# ],
# [
# 0,
# 1
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, type, type:bool) in.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 74 - (tags=clause:in, op, op:and, type, type:bool) in.op=and (ok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'in.op=and (nok + ok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# [],
# [
# 0,
# 1
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:bool) in.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 75 - (tags=clause:in, op, op:and, type, type:bool) in.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'in.op=and (ok + nok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# [
# 0,
# 1
# ],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:bool) in.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 76 - (tags=clause:in, op, op:and, type, type:bool) in.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'in.op=and (nok + nok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:bool) in.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 77 - (tags=clause:in, op, op:and, type, type:bool) in.op=and (nok + nok)
# {
# 'input' => 0,
# 'name' => 'in| (no items)',
# 'schema' => [
# 'bool',
# 'in|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:bool) in| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 78 - (tags=clause:in, op, op:or, opshortcut, type, type:bool) in| (no items)
# {
# 'input' => 0,
# 'name' => 'in| (ok)',
# 'schema' => [
# 'bool',
# 'in|',
# [
# [
# 0,
# 1
# ],
# [
# 0,
# 1
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:bool) in| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 79 - (tags=clause:in, op, op:or, opshortcut, type, type:bool) in| (ok)
# {
# 'input' => 0,
# 'name' => 'in| (nok + ok)',
# 'schema' => [
# 'bool',
# 'in|',
# [
# [],
# [
# 0,
# 1
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:bool) in| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 80 - (tags=clause:in, op, op:or, opshortcut, type, type:bool) in| (nok + ok)
# {
# 'input' => 0,
# 'name' => 'in| (ok + nok)',
# 'schema' => [
# 'bool',
# 'in|',
# [
# [
# 0,
# 1
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:bool) in| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 81 - (tags=clause:in, op, op:or, opshortcut, type, type:bool) in| (ok + nok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'in| (nok + nok)',
# 'schema' => [
# 'bool',
# 'in|',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:bool) in| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 82 - (tags=clause:in, op, op:or, opshortcut, type, type:bool) in| (nok + nok)
# {
# 'input' => 0,
# 'name' => 'in.op=or (no items)',
# 'schema' => [
# 'bool',
# 'in',
# [],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:bool) in.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 83 - (tags=clause:in, op, op:or, type, type:bool) in.op=or (no items)
# {
# 'input' => 0,
# 'name' => 'in.op=or (ok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# [
# 0,
# 1
# ],
# [
# 0,
# 1
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:bool) in.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 84 - (tags=clause:in, op, op:or, type, type:bool) in.op=or (ok)
# {
# 'input' => 0,
# 'name' => 'in.op=or (nok + ok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# [],
# [
# 0,
# 1
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:bool) in.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 85 - (tags=clause:in, op, op:or, type, type:bool) in.op=or (nok + ok)
# {
# 'input' => 0,
# 'name' => 'in.op=or (ok + nok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# [
# 0,
# 1
# ],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:bool) in.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 86 - (tags=clause:in, op, op:or, type, type:bool) in.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'in.op=or (nok + nok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, type, type:bool) in.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 87 - (tags=clause:in, op, op:or, type, type:bool) in.op=or (nok + nok)
# {
# 'input' => 0,
# 'name' => 'in.op=none (empty items)',
# 'schema' => [
# 'bool',
# 'in',
# [],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:bool) in.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 88 - (tags=clause:in, op, op:none, type, type:bool) in.op=none (empty items)
# {
# 'input' => 0,
# 'name' => 'in.op=none (nok + nok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:bool) in.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 89 - (tags=clause:in, op, op:none, type, type:bool) in.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'in.op=none (nok + ok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# [],
# [
# 0,
# 1
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:bool) in.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 90 - (tags=clause:in, op, op:none, type, type:bool) in.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'in.op=none (ok + nok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# [
# 0,
# 1
# ],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:bool) in.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 91 - (tags=clause:in, op, op:none, type, type:bool) in.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => 0,
# 'name' => 'in.op=none (ok + ok)',
# 'schema' => [
# 'bool',
# 'in',
# [
# [
# 0,
# 1
# ],
# [
# 0,
# 1
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:bool) in.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 92 - (tags=clause:in, op, op:none, type, type:bool) in.op=none (ok + ok)
# {
# 'input' => 1,
# 'name' => 'min: 1 0',
# 'schema' => [
# 'bool',
# 'min',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:bool) min: 1 0
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 93 - (tags=clause:min, type, type:bool) min: 1 0
# {
# 'input' => 1,
# 'name' => 'min: 1 1',
# 'schema' => [
# 'bool',
# 'min',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:bool) min: 1 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 94 - (tags=clause:min, type, type:bool) min: 1 1
# {
# 'input' => 0,
# 'name' => 'min: 0 1 -> fail',
# 'schema' => [
# 'bool',
# 'min',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:min'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:min, type, type:bool) min: 0 1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 95 - (tags=clause:min, type, type:bool) min: 0 1 -> fail
# {
# 'input' => 1,
# 'name' => 'xmin: 1 0',
# 'schema' => [
# 'bool',
# 'xmin',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:xmin'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmin, type, type:bool) xmin: 1 0
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 96 - (tags=clause:xmin, type, type:bool) xmin: 1 0
# {
# 'input' => 1,
# 'name' => 'xmin: 1 1 -> fail',
# 'schema' => [
# 'bool',
# 'xmin',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:bool) xmin: 1 1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 97 - (tags=clause:xmin, type, type:bool) xmin: 1 1 -> fail
# {
# 'input' => 0,
# 'name' => 'xmin: 0 1 -> fail',
# 'schema' => [
# 'bool',
# 'xmin',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:bool) xmin: 0 1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 98 - (tags=clause:xmin, type, type:bool) xmin: 0 1 -> fail
# {
# 'input' => 1,
# 'name' => 'max: 1 0 -> fail',
# 'schema' => [
# 'bool',
# 'max',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:max'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:max, type, type:bool) max: 1 0 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 99 - (tags=clause:max, type, type:bool) max: 1 0 -> fail
# {
# 'input' => 1,
# 'name' => 'max: 1 1',
# 'schema' => [
# 'bool',
# 'max',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:bool) max: 1 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 100 - (tags=clause:max, type, type:bool) max: 1 1
# {
# 'input' => 0,
# 'name' => 'max: 0 1',
# 'schema' => [
# 'bool',
# 'max',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:bool) max: 0 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 101 - (tags=clause:max, type, type:bool) max: 0 1
# {
# 'input' => 1,
# 'name' => 'xmax: 1 0 -> fail',
# 'schema' => [
# 'bool',
# 'xmax',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:bool) xmax: 1 0 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 102 - (tags=clause:xmax, type, type:bool) xmax: 1 0 -> fail
# {
# 'input' => 1,
# 'name' => 'xmax: 1 1 -> fail',
# 'schema' => [
# 'bool',
# 'xmax',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:bool) xmax: 1 1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 103 - (tags=clause:xmax, type, type:bool) xmax: 1 1 -> fail
# {
# 'input' => 0,
# 'name' => 'xmax: 0 1',
# 'schema' => [
# 'bool',
# 'xmax',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:xmax'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmax, type, type:bool) xmax: 0 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 104 - (tags=clause:xmax, type, type:bool) xmax: 0 1
# {
# 'input' => 1,
# 'name' => 'between: 1 0 & 1',
# 'schema' => [
# 'bool',
# 'between',
# [
# 0,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:bool) between: 1 0 & 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 105 - (tags=clause:between, type, type:bool) between: 1 0 & 1
# {
# 'input' => 1,
# 'name' => 'between: 1 0 & 1',
# 'schema' => [
# 'bool',
# 'between',
# [
# 0,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:bool) between: 1 0 & 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 106 - (tags=clause:between, type, type:bool) between: 1 0 & 1
# {
# 'input' => 1,
# 'name' => 'between: 1 1 & 1',
# 'schema' => [
# 'bool',
# 'between',
# [
# 1,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:bool) between: 1 1 & 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 107 - (tags=clause:between, type, type:bool) between: 1 1 & 1
# {
# 'input' => 0,
# 'name' => 'between: 0 1 & 1 -> fail',
# 'schema' => [
# 'bool',
# 'between',
# [
# 1,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:between'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, type, type:bool) between: 0 1 & 1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 108 - (tags=clause:between, type, type:bool) between: 0 1 & 1 -> fail
# {
# 'input' => '1',
# 'name' => 'xbetween: 1 0 & 1',
# 'schema' => [
# 'bool',
# 'xbetween',
# [
# 0,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:bool) xbetween: 1 0 & 1
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 109 - (tags=clause:xbetween, type, type:bool) xbetween: 1 0 & 1
# {
# 'input' => '1',
# 'name' => 'xbetween: 1 0 & 1 -> fail',
# 'schema' => [
# 'bool',
# 'xbetween',
# [
# 0,
# '1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:bool) xbetween: 1 0 & 1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 110 - (tags=clause:xbetween, type, type:bool) xbetween: 1 0 & 1 -> fail
# {
# 'input' => '1',
# 'name' => 'xbetween: 1 1 & 1 -> fail',
# 'schema' => [
# 'bool',
# 'xbetween',
# [
# '1',
# '1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:bool) xbetween: 1 1 & 1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 111 - (tags=clause:xbetween, type, type:bool) xbetween: 1 1 & 1 -> fail
# {
# 'input' => 0,
# 'name' => 'xbetween: 0 1 & 1 -> fail',
# 'schema' => [
# 'bool',
# 'xbetween',
# [
# '1',
# '1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:bool) xbetween: 0 1 & 1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 112 - (tags=clause:xbetween, type, type:bool) xbetween: 0 1 & 1 -> fail
# {
# 'input' => 0,
# 'name' => 'between.op=and (no items)',
# 'schema' => [
# 'bool',
# 'between',
# [],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:bool'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:bool) between.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 113 - (tags=type, type:bool) between.op=and (no items)
# {
# 'input' => 1,
# 'name' => 'is_true: 1 (ok)',
# 'schema' => [
# 'bool',
# 'is_true',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is_true'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is_true, type, type:bool) is_true: 1 (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 114 - (tags=clause:is_true, type, type:bool) is_true: 1 (ok)
# {
# 'input' => 0,
# 'name' => 'is_true: 1 (nok)',
# 'schema' => [
# 'bool',
# 'is_true',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is_true'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is_true, type, type:bool) is_true: 1 (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 115 - (tags=clause:is_true, type, type:bool) is_true: 1 (nok)
# {
# 'input' => 0,
# 'name' => 'is_true: 0 (ok)',
# 'schema' => [
# 'bool',
# 'is_true',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is_true'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is_true, type, type:bool) is_true: 0 (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 116 - (tags=clause:is_true, type, type:bool) is_true: 0 (ok)
# {
# 'input' => 1,
# 'name' => 'is_true: 0 (nok)',
# 'schema' => [
# 'bool',
# 'is_true',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is_true'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is_true, type, type:bool) is_true: 0 (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 117 - (tags=clause:is_true, type, type:bool) is_true: 0 (nok)
# {
# 'input' => 0,
# 'name' => 'is_true: undef (ok 1)',
# 'schema' => [
# 'bool',
# 'is_true',
# undef
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is_true'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is_true, type, type:bool) is_true: undef (ok 1)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 118 - (tags=clause:is_true, type, type:bool) is_true: undef (ok 1)
# {
# 'input' => 1,
# 'name' => 'is_true: undef (ok 2)',
# 'schema' => [
# 'bool',
# 'is_true',
# undef
# ],
# 'tags' => [
# 'type',
# 'type:bool',
# 'clause:is_true'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is_true, type, type:bool) is_true: undef (ok 2)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 119 - (tags=clause:is_true, type, type:bool) is_true: undef (ok 2)
ok 120
1..120
ok 6 - 10-type-bool.json
# Subtest: 10-type-buf.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => 0,
# 'name' => 'type check: must accept 0',
# 'schema' => 'buf',
# 'tags' => [
# 'type',
# 'type:buf'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:buf) type check: must accept 0
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=type, type:buf) type check: must accept 0
# {
# 'input' => '1.1',
# 'name' => 'type check: must accept 1.1',
# 'schema' => 'buf',
# 'tags' => [
# 'type',
# 'type:buf'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:buf) type check: must accept 1.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=type, type:buf) type check: must accept 1.1
# {
# 'input' => '',
# 'name' => 'type check: must accept ',
# 'schema' => 'buf',
# 'tags' => [
# 'type',
# 'type:buf'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:buf) type check: must accept
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 3 - (tags=type, type:buf) type check: must accept
# {
# 'input' => 'str
# ',
# 'name' => 'type check: must accept str
# ',
# 'schema' => 'buf',
# 'tags' => [
# 'type',
# 'type:buf'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:buf) type check: must accept str
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 4 - (tags=type, type:buf) type check: must accept str
#
# {
# 'input' => [],
# 'name' => 'type check: must reject []',
# 'schema' => 'buf',
# 'tags' => [
# 'type',
# 'type:buf'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:buf) type check: must reject []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 5 - (tags=type, type:buf) type check: must reject []
# {
# 'input' => {},
# 'name' => 'type check: must reject {}',
# 'schema' => 'buf',
# 'tags' => [
# 'type',
# 'type:buf'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:buf) type check: must reject {}
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 6 - (tags=type, type:buf) type check: must reject {}
# {
# 'input' => undef,
# 'name' => 'must accept undefined value',
# 'schema' => 'buf',
# 'tags' => [
# 'type',
# 'type:buf'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:buf) must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 7 - (tags=type, type:buf) must accept undefined value
# {
# 'input' => undef,
# 'name' => 'defhash_v',
# 'schema' => [
# 'buf',
# 'defhash_v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:defhash_v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:defhash_v, type, type:buf) defhash_v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 8 - (tags=clause:defhash_v, type, type:buf) defhash_v
# {
# 'input' => undef,
# 'name' => 'v',
# 'schema' => [
# 'buf',
# 'v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:v, type, type:buf) v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 9 - (tags=clause:v, type, type:buf) v
# {
# 'input' => undef,
# 'name' => 'c',
# 'schema' => [
# 'buf',
# 'c.foo.bar',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:c'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:c, type, type:buf) c
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 10 - (tags=clause:c, type, type:buf) c
# {
# 'input' => undef,
# 'name' => 'default_lang',
# 'schema' => [
# 'buf',
# 'default_lang',
# 'id_ID'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:default_lang'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default_lang, type, type:buf) default_lang
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 11 - (tags=clause:default_lang, type, type:buf) default_lang
# {
# 'input' => undef,
# 'name' => 'name',
# 'schema' => [
# 'buf',
# 'name',
# 'some name'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:name'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:name, type, type:buf) name
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 12 - (tags=clause:name, type, type:buf) name
# {
# 'input' => undef,
# 'name' => 'summary',
# 'schema' => [
# 'buf',
# 'summary',
# 'some summary'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:summary'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:summary, type, type:buf) summary
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 13 - (tags=clause:summary, type, type:buf) summary
# {
# 'input' => undef,
# 'name' => 'description',
# 'schema' => [
# 'buf',
# 'description',
# 'some description and `markdown`'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:description'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:description, type, type:buf) description
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 14 - (tags=clause:description, type, type:buf) description
# {
# 'input' => undef,
# 'name' => 'tags',
# 'schema' => [
# 'buf',
# 'tags',
# [
# 'some',
# 'tags'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:tags'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:tags, type, type:buf) tags
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 15 - (tags=clause:tags, type, type:buf) tags
# {
# 'input' => undef,
# 'name' => 'req=0 must accept undefined value',
# 'schema' => [
# 'buf',
# 'req',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:req'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req, type, type:buf) req=0 must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 16 - (tags=clause:req, type, type:buf) req=0 must accept undefined value
# {
# 'input' => undef,
# 'name' => 'req=1 must reject undefined value',
# 'schema' => [
# 'buf',
# 'req',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:req'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:req, type, type:buf) req=1 must reject undefined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 17 - (tags=clause:req, type, type:buf) req=1 must reject undefined value
# {
# 'input' => 'a',
# 'name' => 'forbidden=0 must accept defined value',
# 'schema' => [
# 'buf',
# 'forbidden',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:forbidden'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden, type, type:buf) forbidden=0 must accept defined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 18 - (tags=clause:forbidden, type, type:buf) forbidden=0 must accept defined value
# {
# 'input' => 'a',
# 'name' => 'forbidden=1 must reject defined value',
# 'schema' => [
# 'buf',
# 'forbidden',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:forbidden'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:forbidden, type, type:buf) forbidden=1 must reject defined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 19 - (tags=clause:forbidden, type, type:buf) forbidden=1 must reject defined value
# {
# 'input' => undef,
# 'name' => 'default: must accept valid default a',
# 'schema' => [
# 'buf*',
# 'default',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:default'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default, type, type:buf) default: must accept valid default a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 20 - (tags=clause:default, type, type:buf) default: must accept valid default a
# {
# 'input' => undef,
# 'name' => 'default: must reject invalid default []',
# 'schema' => [
# 'buf*',
# 'default',
# []
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:default'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:default, type, type:buf) default: must reject invalid default []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 21 - (tags=clause:default, type, type:buf) default: must reject invalid default []
# {
# 'dies' => 1,
# 'input' => 'a',
# 'name' => 'clause (dies, unknown clause)',
# 'schema' => [
# 'buf*',
# 'clause',
# [
# 'foo',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:clause'
# ]
# }
# Subtest: (tags=clause:clause, type, type:buf) clause (dies, unknown clause)
ok 1 - compile error
1..1
ok 22 - (tags=clause:clause, type, type:buf) clause (dies, unknown clause)
# {
# 'input' => 'a',
# 'name' => 'clause (ok)',
# 'schema' => [
# 'buf*',
# 'clause',
# [
# 'match',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:clause'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clause, type, type:buf) clause (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 23 - (tags=clause:clause, type, type:buf) clause (ok)
# {
# 'input' => 'a',
# 'name' => 'clause (ok) + clause nok = nok',
# 'schema' => [
# 'buf*',
# 'clause',
# [
# 'match',
# 'a'
# ],
# 'len',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:buf) clause (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 24 - (tags=clause:clause, type, type:buf) clause (ok) + clause nok = nok
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'clause (nok)',
# 'schema' => [
# 'buf*',
# 'clause',
# [
# 'match',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:buf) clause (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 25 - (tags=clause:clause, type, type:buf) clause (nok)
# {
# 'dies' => 1,
# 'input' => 'a',
# 'name' => 'clset (dies, unknown clause)',
# 'schema' => [
# 'buf*',
# 'clset',
# {
# 'foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:buf) clset (dies, unknown clause)
ok 1 - compile error
1..1
ok 26 - (tags=clause:clset, type, type:buf) clset (dies, unknown clause)
# {
# 'dies' => 1,
# 'input' => 'a',
# 'name' => 'clset (dies, unknown attr)',
# 'schema' => [
# 'buf*',
# 'clset',
# {
# 'min_len' => 1,
# 'min_len.foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:buf) clset (dies, unknown attr)
ok 1 - compile error
1..1
ok 27 - (tags=clause:clset, type, type:buf) clset (dies, unknown attr)
# {
# 'input' => 'a',
# 'name' => 'clset (empty = ok)',
# 'schema' => [
# 'buf*',
# 'clset',
# {}
# ],
# 'tags' => [
# 'type',
# 'type:buf'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:buf) clset (empty = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 28 - (tags=type, type:buf) clset (empty = ok)
# {
# 'input' => 'a',
# 'name' => 'clset (ignored clause/attr = ok)',
# 'schema' => [
# 'buf*',
# 'clset',
# {
# '_foo' => 1,
# 'foo._bar' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:buf) clset (ignored clause/attr = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 29 - (tags=clause:clset, type, type:buf) clset (ignored clause/attr = ok)
# {
# 'input' => 'a',
# 'name' => 'clset (ok + ok = ok)',
# 'schema' => [
# 'buf*',
# 'clset',
# {
# 'len' => 1,
# 'match' => 'a'
# }
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:buf) clset (ok + ok = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 30 - (tags=clause:clset, type, type:buf) clset (ok + ok = ok)
# {
# 'input' => 'a',
# 'name' => 'clset (ok) + clause nok = nok',
# 'schema' => [
# 'buf*',
# 'clset',
# {
# 'match' => 'a'
# },
# 'len',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:buf) clset (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 31 - (tags=clause:clset, type, type:buf) clset (ok) + clause nok = nok
# {
# 'input' => 'a',
# 'name' => 'clset (ok + nok = nok)',
# 'schema' => [
# 'buf*',
# 'clset',
# {
# 'len' => 2,
# 'match' => 'a'
# }
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:buf) clset (ok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 32 - (tags=clause:clset, type, type:buf) clset (ok + nok = nok)
# {
# 'input' => 'a',
# 'name' => 'clset (nok + ok = nok)',
# 'schema' => [
# 'buf*',
# 'clset',
# {
# 'len' => 1,
# 'match' => 'b'
# }
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:buf) clset (nok + ok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 33 - (tags=clause:clset, type, type:buf) clset (nok + ok = nok)
# {
# 'input' => 'a',
# 'name' => 'clset (nok + nok = nok)',
# 'schema' => [
# 'buf*',
# 'clset',
# {
# 'len' => 2,
# 'match' => 'b'
# }
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:buf) clset (nok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 34 - (tags=clause:clset, type, type:buf) clset (nok + nok = nok)
# {
# 'input' => undef,
# 'name' => 'ok',
# 'schema' => [
# 'buf',
# {
# 'ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:ok'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:ok, type, type:buf) ok
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 35 - (tags=clause:ok, type, type:buf) ok
# {
# 'input' => undef,
# 'name' => 'ok + op not (nok)',
# 'schema' => [
# 'buf',
# {
# '!ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:ok',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:ok, op, op:not, type, type:buf) ok + op not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 36 - (tags=clause:ok, op, op:not, type, type:buf) ok + op not (nok)
# {
# 'input' => 'a',
# 'name' => '.err_level=error (clause=is, ok)',
# 'schema' => [
# 'buf',
# 'is',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:buf) .err_level=error (clause=is, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 37 - (tags=attr, attr:err_level, type, type:buf) .err_level=error (clause=is, ok)
# {
# 'input' => 'a
# ',
# 'name' => '.err_level=error (clause=is, nok)',
# 'schema' => [
# 'buf',
# 'is',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 0
# }
# Subtest: (tags=attr, attr:err_level, type, type:buf) .err_level=error (clause=is, nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 38 - (tags=attr, attr:err_level, type, type:buf) .err_level=error (clause=is, nok)
# {
# 'input' => 'a',
# 'name' => '.err_level=warn (clause=is, ok)',
# 'schema' => [
# 'buf',
# 'is',
# 'a',
# 'is.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:buf) .err_level=warn (clause=is, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 39 - (tags=attr, attr:err_level, type, type:buf) .err_level=warn (clause=is, ok)
# {
# 'input' => 'a
# ',
# 'name' => '.err_level=warn (clause=is, nok)',
# 'schema' => [
# 'buf*',
# 'is',
# 'a',
# 'is.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1,
# 'warnings' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:buf) .err_level=warn (clause=is, nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 40 - (tags=attr, attr:err_level, type, type:buf) .err_level=warn (clause=is, nok)
# {
# 'input' => 'a',
# 'name' => 'is: must accept same value',
# 'schema' => [
# 'buf',
# 'is',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, type, type:buf) is: must accept same value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 41 - (tags=clause:is, type, type:buf) is: must accept same value
# {
# 'input' => 'a',
# 'name' => 'is: must reject different value',
# 'schema' => [
# 'buf',
# 'is',
# 'b'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, type, type:buf) is: must reject different value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 42 - (tags=clause:is, type, type:buf) is: must reject different value
# {
# 'input' => 'a',
# 'name' => '!is (nok)',
# 'schema' => [
# 'buf',
# '!is',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:buf) !is (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 43 - (tags=clause:is, op, op:not, opshortcut, type, type:buf) !is (nok)
# {
# 'input' => 'a',
# 'name' => '!is (ok)',
# 'schema' => [
# 'buf',
# '!is',
# 'b'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:buf) !is (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 44 - (tags=clause:is, op, op:not, opshortcut, type, type:buf) !is (ok)
# {
# 'input' => 'a',
# 'name' => 'is.op=not (nok)',
# 'schema' => [
# 'buf',
# 'is',
# 'a',
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, type, type:buf) is.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 45 - (tags=clause:is, op, op:not, type, type:buf) is.op=not (nok)
# {
# 'input' => 'a',
# 'name' => 'is.op=not (ok)',
# 'schema' => [
# 'buf',
# 'is',
# 'b',
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, type, type:buf) is.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 46 - (tags=clause:is, op, op:not, type, type:buf) is.op=not (ok)
# {
# 'input' => 'a',
# 'name' => 'is& (no items)',
# 'schema' => [
# 'buf',
# 'is&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:buf) is& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 47 - (tags=clause:is, op, op:and, opshortcut, type, type:buf) is& (no items)
# {
# 'input' => 'a',
# 'name' => 'is& (ok)',
# 'schema' => [
# 'buf',
# 'is&',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:buf) is& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 48 - (tags=clause:is, op, op:and, opshortcut, type, type:buf) is& (ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is& (nok + ok)',
# 'schema' => [
# 'buf',
# 'is&',
# [
# 'b',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:buf) is& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 49 - (tags=clause:is, op, op:and, opshortcut, type, type:buf) is& (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is& (ok + nok)',
# 'schema' => [
# 'buf',
# 'is&',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:buf) is& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 50 - (tags=clause:is, op, op:and, opshortcut, type, type:buf) is& (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is& (nok + nok)',
# 'schema' => [
# 'buf',
# 'is&',
# [
# 'b',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:buf) is& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 51 - (tags=clause:is, op, op:and, opshortcut, type, type:buf) is& (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'is.op=and (no items)',
# 'schema' => [
# 'buf',
# 'is',
# [],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:buf) is.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 52 - (tags=type, type:buf) is.op=and (no items)
# {
# 'input' => 'a',
# 'name' => 'is.op=and (ok)',
# 'schema' => [
# 'buf',
# 'is',
# [
# 'a',
# 'a'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, type, type:buf) is.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 53 - (tags=clause:is, op, op:and, type, type:buf) is.op=and (ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=and (nok + ok)',
# 'schema' => [
# 'buf',
# 'is',
# [
# 'b',
# 'a'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:buf) is.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 54 - (tags=clause:is, op, op:and, type, type:buf) is.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=and (ok + nok)',
# 'schema' => [
# 'buf',
# 'is',
# [
# 'a',
# 'b'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:buf) is.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 55 - (tags=clause:is, op, op:and, type, type:buf) is.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=and (nok + nok)',
# 'schema' => [
# 'buf',
# 'is',
# [
# 'b',
# 'b'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:buf) is.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 56 - (tags=clause:is, op, op:and, type, type:buf) is.op=and (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'is| (no items)',
# 'schema' => [
# 'buf',
# 'is|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:buf) is| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 57 - (tags=clause:is, op, op:or, opshortcut, type, type:buf) is| (no items)
# {
# 'input' => 'a',
# 'name' => 'is| (ok)',
# 'schema' => [
# 'buf',
# 'is|',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:buf) is| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 58 - (tags=clause:is, op, op:or, opshortcut, type, type:buf) is| (ok)
# {
# 'input' => 'a',
# 'name' => 'is| (nok + ok)',
# 'schema' => [
# 'buf',
# 'is|',
# [
# 'b',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:buf) is| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 59 - (tags=clause:is, op, op:or, opshortcut, type, type:buf) is| (nok + ok)
# {
# 'input' => 'a',
# 'name' => 'is| (ok + nok)',
# 'schema' => [
# 'buf',
# 'is|',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:buf) is| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 60 - (tags=clause:is, op, op:or, opshortcut, type, type:buf) is| (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is| (nok + nok)',
# 'schema' => [
# 'buf',
# 'is|',
# [
# 'b',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:buf) is| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 61 - (tags=clause:is, op, op:or, opshortcut, type, type:buf) is| (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'is.op=or (no items)',
# 'schema' => [
# 'buf',
# 'is',
# [],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:buf) is.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 62 - (tags=clause:is, op, op:or, type, type:buf) is.op=or (no items)
# {
# 'input' => 'a',
# 'name' => 'is.op=or (ok)',
# 'schema' => [
# 'buf',
# 'is',
# [
# 'a',
# 'a'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:buf) is.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 63 - (tags=clause:is, op, op:or, type, type:buf) is.op=or (ok)
# {
# 'input' => 'a',
# 'name' => 'is.op=or (nok + ok)',
# 'schema' => [
# 'buf',
# 'is',
# [
# 'b',
# 'a'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:buf) is.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 64 - (tags=clause:is, op, op:or, type, type:buf) is.op=or (nok + ok)
# {
# 'input' => 'a',
# 'name' => 'is.op=or (ok + nok)',
# 'schema' => [
# 'buf',
# 'is',
# [
# 'a',
# 'b'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:buf) is.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 65 - (tags=clause:is, op, op:or, type, type:buf) is.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=or (nok + nok)',
# 'schema' => [
# 'buf',
# 'is',
# [
# 'b',
# 'b'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, type, type:buf) is.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 66 - (tags=clause:is, op, op:or, type, type:buf) is.op=or (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'is.op=none (empty items)',
# 'schema' => [
# 'buf',
# 'is',
# [],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:buf) is.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 67 - (tags=clause:is, op, op:none, type, type:buf) is.op=none (empty items)
# {
# 'input' => 'a',
# 'name' => 'is.op=none (nok + nok)',
# 'schema' => [
# 'buf',
# 'is',
# [
# 'b',
# 'b'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:buf) is.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 68 - (tags=clause:is, op, op:none, type, type:buf) is.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=none (nok + ok)',
# 'schema' => [
# 'buf',
# 'is',
# [
# 'b',
# 'a'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:buf) is.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 69 - (tags=clause:is, op, op:none, type, type:buf) is.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=none (ok + nok)',
# 'schema' => [
# 'buf',
# 'is',
# [
# 'a',
# 'b'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:buf) is.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 70 - (tags=clause:is, op, op:none, type, type:buf) is.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=none (ok + ok)',
# 'schema' => [
# 'buf',
# 'is',
# [
# 'a',
# 'a'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:buf) is.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 71 - (tags=clause:is, op, op:none, type, type:buf) is.op=none (ok + ok)
# {
# 'input' => 'a',
# 'name' => 'in: must accept valid choices',
# 'schema' => [
# 'buf',
# 'in',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, type, type:buf) in: must accept valid choices
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 72 - (tags=clause:in, type, type:buf) in: must accept valid choices
# {
# 'input' => 'a',
# 'name' => 'in: must reject empty choices',
# 'schema' => [
# 'buf',
# 'in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, type, type:buf) in: must reject empty choices
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 73 - (tags=clause:in, type, type:buf) in: must reject empty choices
# {
# 'input' => 'a',
# 'name' => '!in (nok)',
# 'schema' => [
# 'buf',
# '!in',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:buf) !in (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 74 - (tags=clause:in, op, op:not, opshortcut, type, type:buf) !in (nok)
# {
# 'input' => 'a',
# 'name' => '!in (ok)',
# 'schema' => [
# 'buf',
# '!in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:buf) !in (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 75 - (tags=clause:in, op, op:not, opshortcut, type, type:buf) !in (ok)
# {
# 'input' => 'a',
# 'name' => 'in.op=not (nok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# 'a',
# 'b'
# ],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, type, type:buf) in.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 76 - (tags=clause:in, op, op:not, type, type:buf) in.op=not (nok)
# {
# 'input' => 'a',
# 'name' => 'in.op=not (ok)',
# 'schema' => [
# 'buf',
# 'in',
# [],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, type, type:buf) in.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 77 - (tags=clause:in, op, op:not, type, type:buf) in.op=not (ok)
# {
# 'input' => 'a',
# 'name' => 'in& (no items)',
# 'schema' => [
# 'buf',
# 'in&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:buf) in& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 78 - (tags=clause:in, op, op:and, opshortcut, type, type:buf) in& (no items)
# {
# 'input' => 'a',
# 'name' => 'in& (ok)',
# 'schema' => [
# 'buf',
# 'in&',
# [
# [
# 'a',
# 'b'
# ],
# [
# 'a',
# 'b'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:buf) in& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 79 - (tags=clause:in, op, op:and, opshortcut, type, type:buf) in& (ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in& (nok + ok)',
# 'schema' => [
# 'buf',
# 'in&',
# [
# [],
# [
# 'a',
# 'b'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:buf) in& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 80 - (tags=clause:in, op, op:and, opshortcut, type, type:buf) in& (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in& (ok + nok)',
# 'schema' => [
# 'buf',
# 'in&',
# [
# [
# 'a',
# 'b'
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:buf) in& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 81 - (tags=clause:in, op, op:and, opshortcut, type, type:buf) in& (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in& (nok + nok)',
# 'schema' => [
# 'buf',
# 'in&',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:buf) in& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 82 - (tags=clause:in, op, op:and, opshortcut, type, type:buf) in& (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'in.op=and (no items)',
# 'schema' => [
# 'buf',
# 'in',
# [],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:buf) in.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 83 - (tags=type, type:buf) in.op=and (no items)
# {
# 'input' => 'a',
# 'name' => 'in.op=and (ok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# [
# 'a',
# 'b'
# ],
# [
# 'a',
# 'b'
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, type, type:buf) in.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 84 - (tags=clause:in, op, op:and, type, type:buf) in.op=and (ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=and (nok + ok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# [],
# [
# 'a',
# 'b'
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:buf) in.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 85 - (tags=clause:in, op, op:and, type, type:buf) in.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=and (ok + nok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# [
# 'a',
# 'b'
# ],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:buf) in.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 86 - (tags=clause:in, op, op:and, type, type:buf) in.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=and (nok + nok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:buf) in.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 87 - (tags=clause:in, op, op:and, type, type:buf) in.op=and (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'in| (no items)',
# 'schema' => [
# 'buf',
# 'in|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:buf) in| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 88 - (tags=clause:in, op, op:or, opshortcut, type, type:buf) in| (no items)
# {
# 'input' => 'a',
# 'name' => 'in| (ok)',
# 'schema' => [
# 'buf',
# 'in|',
# [
# [
# 'a',
# 'b'
# ],
# [
# 'a',
# 'b'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:buf) in| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 89 - (tags=clause:in, op, op:or, opshortcut, type, type:buf) in| (ok)
# {
# 'input' => 'a',
# 'name' => 'in| (nok + ok)',
# 'schema' => [
# 'buf',
# 'in|',
# [
# [],
# [
# 'a',
# 'b'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:buf) in| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 90 - (tags=clause:in, op, op:or, opshortcut, type, type:buf) in| (nok + ok)
# {
# 'input' => 'a',
# 'name' => 'in| (ok + nok)',
# 'schema' => [
# 'buf',
# 'in|',
# [
# [
# 'a',
# 'b'
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:buf) in| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 91 - (tags=clause:in, op, op:or, opshortcut, type, type:buf) in| (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in| (nok + nok)',
# 'schema' => [
# 'buf',
# 'in|',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:buf) in| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 92 - (tags=clause:in, op, op:or, opshortcut, type, type:buf) in| (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'in.op=or (no items)',
# 'schema' => [
# 'buf',
# 'in',
# [],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:buf) in.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 93 - (tags=clause:in, op, op:or, type, type:buf) in.op=or (no items)
# {
# 'input' => 'a',
# 'name' => 'in.op=or (ok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# [
# 'a',
# 'b'
# ],
# [
# 'a',
# 'b'
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:buf) in.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 94 - (tags=clause:in, op, op:or, type, type:buf) in.op=or (ok)
# {
# 'input' => 'a',
# 'name' => 'in.op=or (nok + ok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# [],
# [
# 'a',
# 'b'
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:buf) in.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 95 - (tags=clause:in, op, op:or, type, type:buf) in.op=or (nok + ok)
# {
# 'input' => 'a',
# 'name' => 'in.op=or (ok + nok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# [
# 'a',
# 'b'
# ],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:buf) in.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 96 - (tags=clause:in, op, op:or, type, type:buf) in.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=or (nok + nok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, type, type:buf) in.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 97 - (tags=clause:in, op, op:or, type, type:buf) in.op=or (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'in.op=none (empty items)',
# 'schema' => [
# 'buf',
# 'in',
# [],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:buf) in.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 98 - (tags=clause:in, op, op:none, type, type:buf) in.op=none (empty items)
# {
# 'input' => 'a',
# 'name' => 'in.op=none (nok + nok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:buf) in.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 99 - (tags=clause:in, op, op:none, type, type:buf) in.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=none (nok + ok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# [],
# [
# 'a',
# 'b'
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:buf) in.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 100 - (tags=clause:in, op, op:none, type, type:buf) in.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=none (ok + nok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# [
# 'a',
# 'b'
# ],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:buf) in.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 101 - (tags=clause:in, op, op:none, type, type:buf) in.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=none (ok + ok)',
# 'schema' => [
# 'buf',
# 'in',
# [
# [
# 'a',
# 'b'
# ],
# [
# 'a',
# 'b'
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:buf) in.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 102 - (tags=clause:in, op, op:none, type, type:buf) in.op=none (ok + ok)
# {
# 'input' => 'a',
# 'name' => 'min: a ',
# 'schema' => [
# 'buf',
# 'min',
# ''
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:buf) min: a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 103 - (tags=clause:min, type, type:buf) min: a
# {
# 'input' => 'a',
# 'name' => 'min: a a',
# 'schema' => [
# 'buf',
# 'min',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:buf) min: a a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 104 - (tags=clause:min, type, type:buf) min: a a
# {
# 'input' => '',
# 'name' => 'min: a -> fail',
# 'schema' => [
# 'buf',
# 'min',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:min'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:min, type, type:buf) min: a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 105 - (tags=clause:min, type, type:buf) min: a -> fail
# {
# 'input' => 'a',
# 'name' => 'xmin: a ',
# 'schema' => [
# 'buf',
# 'xmin',
# ''
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:xmin'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmin, type, type:buf) xmin: a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 106 - (tags=clause:xmin, type, type:buf) xmin: a
# {
# 'input' => 'a',
# 'name' => 'xmin: a a -> fail',
# 'schema' => [
# 'buf',
# 'xmin',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:buf) xmin: a a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 107 - (tags=clause:xmin, type, type:buf) xmin: a a -> fail
# {
# 'input' => '',
# 'name' => 'xmin: a -> fail',
# 'schema' => [
# 'buf',
# 'xmin',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:buf) xmin: a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 108 - (tags=clause:xmin, type, type:buf) xmin: a -> fail
# {
# 'input' => 'a',
# 'name' => 'max: a -> fail',
# 'schema' => [
# 'buf',
# 'max',
# ''
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:max'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:max, type, type:buf) max: a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 109 - (tags=clause:max, type, type:buf) max: a -> fail
# {
# 'input' => 'a',
# 'name' => 'max: a a',
# 'schema' => [
# 'buf',
# 'max',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:buf) max: a a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 110 - (tags=clause:max, type, type:buf) max: a a
# {
# 'input' => '',
# 'name' => 'max: a',
# 'schema' => [
# 'buf',
# 'max',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:buf) max: a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 111 - (tags=clause:max, type, type:buf) max: a
# {
# 'input' => 'a',
# 'name' => 'xmax: a -> fail',
# 'schema' => [
# 'buf',
# 'xmax',
# ''
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:buf) xmax: a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 112 - (tags=clause:xmax, type, type:buf) xmax: a -> fail
# {
# 'input' => 'a',
# 'name' => 'xmax: a a -> fail',
# 'schema' => [
# 'buf',
# 'xmax',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:buf) xmax: a a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 113 - (tags=clause:xmax, type, type:buf) xmax: a a -> fail
# {
# 'input' => '',
# 'name' => 'xmax: a',
# 'schema' => [
# 'buf',
# 'xmax',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:xmax'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmax, type, type:buf) xmax: a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 114 - (tags=clause:xmax, type, type:buf) xmax: a
# {
# 'input' => 'a',
# 'name' => 'between: a & ab',
# 'schema' => [
# 'buf',
# 'between',
# [
# '',
# 'ab'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:buf) between: a & ab
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 115 - (tags=clause:between, type, type:buf) between: a & ab
# {
# 'input' => 'a',
# 'name' => 'between: a & a',
# 'schema' => [
# 'buf',
# 'between',
# [
# '',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:buf) between: a & a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 116 - (tags=clause:between, type, type:buf) between: a & a
# {
# 'input' => 'a',
# 'name' => 'between: a a & a',
# 'schema' => [
# 'buf',
# 'between',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:buf) between: a a & a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 117 - (tags=clause:between, type, type:buf) between: a a & a
# {
# 'input' => '',
# 'name' => 'between: a & ab -> fail',
# 'schema' => [
# 'buf',
# 'between',
# [
# 'a',
# 'ab'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, type, type:buf) between: a & ab -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 118 - (tags=clause:between, type, type:buf) between: a & ab -> fail
# {
# 'input' => 'a',
# 'name' => 'xbetween: a & ab',
# 'schema' => [
# 'buf',
# 'xbetween',
# [
# '',
# 'ab'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:xbetween'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xbetween, type, type:buf) xbetween: a & ab
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 119 - (tags=clause:xbetween, type, type:buf) xbetween: a & ab
# {
# 'input' => 'a',
# 'name' => 'xbetween: a & a -> fail',
# 'schema' => [
# 'buf',
# 'xbetween',
# [
# '',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:buf) xbetween: a & a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 120 - (tags=clause:xbetween, type, type:buf) xbetween: a & a -> fail
# {
# 'input' => 'a',
# 'name' => 'xbetween: a a & a -> fail',
# 'schema' => [
# 'buf',
# 'xbetween',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:buf) xbetween: a a & a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 121 - (tags=clause:xbetween, type, type:buf) xbetween: a a & a -> fail
# {
# 'input' => '',
# 'name' => 'xbetween: a & ab -> fail',
# 'schema' => [
# 'buf',
# 'xbetween',
# [
# 'a',
# 'ab'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:buf) xbetween: a & ab -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 122 - (tags=clause:xbetween, type, type:buf) xbetween: a & ab -> fail
# {
# 'input' => '',
# 'name' => '!between (nok)',
# 'schema' => [
# 'buf',
# '!between',
# [
# '',
# ''
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:not, opshortcut, type, type:buf) !between (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 123 - (tags=clause:between, op, op:not, opshortcut, type, type:buf) !between (nok)
# {
# 'input' => '',
# 'name' => '!between (ok)',
# 'schema' => [
# 'buf',
# '!between',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:not, opshortcut, type, type:buf) !between (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 124 - (tags=clause:between, op, op:not, opshortcut, type, type:buf) !between (ok)
# {
# 'input' => '',
# 'name' => 'between.op=not (nok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# '',
# ''
# ],
# 'between.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:not, type, type:buf) between.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 125 - (tags=clause:between, op, op:not, type, type:buf) between.op=not (nok)
# {
# 'input' => '',
# 'name' => 'between.op=not (ok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# 'a',
# 'a'
# ],
# 'between.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:not, type, type:buf) between.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 126 - (tags=clause:between, op, op:not, type, type:buf) between.op=not (ok)
# {
# 'input' => '',
# 'name' => 'between& (no items)',
# 'schema' => [
# 'buf',
# 'between&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:buf) between& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 127 - (tags=clause:between, op, op:and, opshortcut, type, type:buf) between& (no items)
# {
# 'input' => '',
# 'name' => 'between& (ok)',
# 'schema' => [
# 'buf',
# 'between&',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:buf) between& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 128 - (tags=clause:between, op, op:and, opshortcut, type, type:buf) between& (ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between& (nok + ok)',
# 'schema' => [
# 'buf',
# 'between&',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:buf) between& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 129 - (tags=clause:between, op, op:and, opshortcut, type, type:buf) between& (nok + ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between& (ok + nok)',
# 'schema' => [
# 'buf',
# 'between&',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:buf) between& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 130 - (tags=clause:between, op, op:and, opshortcut, type, type:buf) between& (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between& (nok + nok)',
# 'schema' => [
# 'buf',
# 'between&',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:buf) between& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 131 - (tags=clause:between, op, op:and, opshortcut, type, type:buf) between& (nok + nok)
# {
# 'input' => '',
# 'name' => 'between.op=and (no items)',
# 'schema' => [
# 'buf',
# 'between',
# [],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:buf) between.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 132 - (tags=type, type:buf) between.op=and (no items)
# {
# 'input' => '',
# 'name' => 'between.op=and (ok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, type, type:buf) between.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 133 - (tags=clause:between, op, op:and, type, type:buf) between.op=and (ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=and (nok + ok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:buf) between.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 134 - (tags=clause:between, op, op:and, type, type:buf) between.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=and (ok + nok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:buf) between.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 135 - (tags=clause:between, op, op:and, type, type:buf) between.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=and (nok + nok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:buf) between.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 136 - (tags=clause:between, op, op:and, type, type:buf) between.op=and (nok + nok)
# {
# 'input' => '',
# 'name' => 'between| (no items)',
# 'schema' => [
# 'buf',
# 'between|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:buf) between| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 137 - (tags=clause:between, op, op:or, opshortcut, type, type:buf) between| (no items)
# {
# 'input' => '',
# 'name' => 'between| (ok)',
# 'schema' => [
# 'buf',
# 'between|',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:buf) between| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 138 - (tags=clause:between, op, op:or, opshortcut, type, type:buf) between| (ok)
# {
# 'input' => '',
# 'name' => 'between| (nok + ok)',
# 'schema' => [
# 'buf',
# 'between|',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:buf) between| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 139 - (tags=clause:between, op, op:or, opshortcut, type, type:buf) between| (nok + ok)
# {
# 'input' => '',
# 'name' => 'between| (ok + nok)',
# 'schema' => [
# 'buf',
# 'between|',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:buf) between| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 140 - (tags=clause:between, op, op:or, opshortcut, type, type:buf) between| (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between| (nok + nok)',
# 'schema' => [
# 'buf',
# 'between|',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:buf) between| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 141 - (tags=clause:between, op, op:or, opshortcut, type, type:buf) between| (nok + nok)
# {
# 'input' => '',
# 'name' => 'between.op=or (no items)',
# 'schema' => [
# 'buf',
# 'between',
# [],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:buf) between.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 142 - (tags=clause:between, op, op:or, type, type:buf) between.op=or (no items)
# {
# 'input' => '',
# 'name' => 'between.op=or (ok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:buf) between.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 143 - (tags=clause:between, op, op:or, type, type:buf) between.op=or (ok)
# {
# 'input' => '',
# 'name' => 'between.op=or (nok + ok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:buf) between.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 144 - (tags=clause:between, op, op:or, type, type:buf) between.op=or (nok + ok)
# {
# 'input' => '',
# 'name' => 'between.op=or (ok + nok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:buf) between.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 145 - (tags=clause:between, op, op:or, type, type:buf) between.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=or (nok + nok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:or, type, type:buf) between.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 146 - (tags=clause:between, op, op:or, type, type:buf) between.op=or (nok + nok)
# {
# 'input' => '',
# 'name' => 'between.op=none (empty items)',
# 'schema' => [
# 'buf',
# 'between',
# [],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:none, type, type:buf) between.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 147 - (tags=clause:between, op, op:none, type, type:buf) between.op=none (empty items)
# {
# 'input' => '',
# 'name' => 'between.op=none (nok + nok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:none, type, type:buf) between.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 148 - (tags=clause:between, op, op:none, type, type:buf) between.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=none (nok + ok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:buf) between.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 149 - (tags=clause:between, op, op:none, type, type:buf) between.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=none (ok + nok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:buf) between.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 150 - (tags=clause:between, op, op:none, type, type:buf) between.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=none (ok + ok)',
# 'schema' => [
# 'buf',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:buf) between.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 151 - (tags=clause:between, op, op:none, type, type:buf) between.op=none (ok + ok)
# {
# 'input' => 'a',
# 'name' => 'len (ok)',
# 'schema' => [
# 'buf',
# 'len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:len, type, type:buf) len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 152 - (tags=clause:len, type, type:buf) len (ok)
# {
# 'input' => 'a',
# 'name' => 'len (nok)',
# 'schema' => [
# 'buf',
# 'len',
# 3
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:len, type, type:buf) len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 153 - (tags=clause:len, type, type:buf) len (nok)
# {
# 'input' => 'a',
# 'name' => 'min_len (ok)',
# 'schema' => [
# 'buf',
# 'min_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:min_len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min_len, type, type:buf) min_len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 154 - (tags=clause:min_len, type, type:buf) min_len (ok)
# {
# 'input' => 'a',
# 'name' => 'min_len (nok)',
# 'schema' => [
# 'buf',
# 'min_len',
# 3
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:min_len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:min_len, type, type:buf) min_len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 155 - (tags=clause:min_len, type, type:buf) min_len (nok)
# {
# 'input' => 'a',
# 'name' => 'max_len (ok)',
# 'schema' => [
# 'buf',
# 'min_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:max_len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max_len, type, type:buf) max_len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 156 - (tags=clause:max_len, type, type:buf) max_len (ok)
# {
# 'input' => 'abc',
# 'name' => 'max_len (nok)',
# 'schema' => [
# 'buf',
# 'max_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:max_len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:max_len, type, type:buf) max_len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 157 - (tags=clause:max_len, type, type:buf) max_len (nok)
# {
# 'input' => 'a',
# 'name' => 'len_between (ok)',
# 'schema' => [
# 'buf',
# 'len_between',
# [
# 1,
# 3
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:len_between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:len_between, type, type:buf) len_between (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 158 - (tags=clause:len_between, type, type:buf) len_between (ok)
# {
# 'input' => 'abc',
# 'name' => 'len_between (nok)',
# 'schema' => [
# 'buf',
# 'len_between',
# [
# 1,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:len_between'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:len_between, type, type:buf) len_between (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 159 - (tags=clause:len_between, type, type:buf) len_between (nok)
# {
# 'input' => 'abc',
# 'name' => 'each_index (ok)',
# 'schema' => [
# 'buf',
# 'each_index',
# [
# 'int',
# 'max',
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:each_index'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:each_index, type, type:buf) each_index (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 160 - (tags=clause:each_index, type, type:buf) each_index (ok)
# {
# 'input' => 'abc',
# 'name' => 'each_index (nok)',
# 'schema' => [
# 'buf',
# 'each_index',
# [
# 'int',
# 'xmax',
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:each_index'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:each_index, type, type:buf) each_index (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 161 - (tags=clause:each_index, type, type:buf) each_index (nok)
# {
# 'input' => 'abc',
# 'name' => 'each_elem (ok)',
# 'schema' => [
# 'buf',
# 'each_elem',
# 'buf'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:each_elem'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:each_elem, type, type:buf) each_elem (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 162 - (tags=clause:each_elem, type, type:buf) each_elem (ok)
# {
# 'input' => 'abc',
# 'name' => 'each_elem (nok)',
# 'schema' => [
# 'buf',
# 'each_elem',
# 'float'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:each_elem'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:each_elem, type, type:buf) each_elem (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 163 - (tags=clause:each_elem, type, type:buf) each_elem (nok)
# {
# 'invalid_inputs' => [
# '',
# 'A',
# 'c'
# ],
# 'name' => 'has',
# 'schema' => [
# 'buf',
# 'has',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:has'
# ],
# 'valid_inputs' => [
# 'abc',
# 'ac'
# ]
# }
# Subtest: (tags=clause:has, type, type:buf) has
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - invalid input [2]
ok 7 - validator (rt=full) returns hash
1..7
ok 164 - (tags=clause:has, type, type:buf) has
# {
# 'invalid_inputs' => [
# 'abc',
# 'ac'
# ],
# 'name' => 'has + op.not',
# 'schema' => [
# 'buf',
# '!has',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:has',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# '',
# 'A',
# 'c'
# ]
# }
# Subtest: (tags=clause:has, op, op:not, opshortcut, type, type:buf) has + op.not
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - valid input [2]
ok 5 - invalid input [0]
ok 6 - invalid input [1]
ok 7 - validator (rt=full) returns hash
1..7
ok 165 - (tags=clause:has, op, op:not, opshortcut, type, type:buf) has + op.not
# {
# 'invalid_inputs' => [
# '',
# 'A',
# 'c'
# ],
# 'name' => 'has + op.or',
# 'schema' => [
# 'buf',
# 'has|',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:has',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# 'abc',
# 'ac'
# ]
# }
# Subtest: (tags=clause:has, op, op:or, opshortcut, type, type:buf) has + op.or
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - invalid input [2]
ok 7 - validator (rt=full) returns hash
1..7
ok 166 - (tags=clause:has, op, op:or, opshortcut, type, type:buf) has + op.or
# {
# 'invalid_inputs' => [
# 'ac',
# '',
# 'A',
# 'c'
# ],
# 'name' => 'has + op.and',
# 'schema' => [
# 'buf',
# 'has&',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:has',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# 'abc'
# ]
# }
# Subtest: (tags=clause:has, op, op:and, opshortcut, type, type:buf) has + op.and
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - invalid input [0]
ok 4 - invalid input [1]
ok 5 - invalid input [2]
ok 6 - invalid input [3]
ok 7 - validator (rt=full) returns hash
1..7
ok 167 - (tags=clause:has, op, op:and, opshortcut, type, type:buf) has + op.and
# {
# 'input' => 'a',
# 'name' => 'match: (ok)',
# 'schema' => [
# 'buf',
# 'match',
# '[abc]'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:match'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:match, type, type:buf) match: (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 168 - (tags=clause:match, type, type:buf) match: (ok)
# {
# 'input' => 'A',
# 'name' => 'match: (nok)',
# 'schema' => [
# 'buf',
# 'match',
# '[abc]'
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:match'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:match, type, type:buf) match: (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 169 - (tags=clause:match, type, type:buf) match: (nok)
# {
# 'dies' => 1,
# 'input' => 'a',
# 'name' => 'match: (dies, invalid regex)',
# 'schema' => [
# 'buf',
# 'match',
# '('
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:match'
# ]
# }
# Subtest: (tags=clause:match, type, type:buf) match: (dies, invalid regex)
ok 1 - compile error
1..1
ok 170 - (tags=clause:match, type, type:buf) match: (dies, invalid regex)
# {
# 'input' => 'a',
# 'name' => 'is_re: 1 (ok)',
# 'schema' => [
# 'buf',
# 'is_re',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is_re'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is_re, type, type:buf) is_re: 1 (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 171 - (tags=clause:is_re, type, type:buf) is_re: 1 (ok)
# {
# 'input' => 'a(',
# 'name' => 'is_re: 1 (nok)',
# 'schema' => [
# 'buf',
# 'is_re',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is_re'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is_re, type, type:buf) is_re: 1 (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 172 - (tags=clause:is_re, type, type:buf) is_re: 1 (nok)
# {
# 'input' => 'a(',
# 'name' => 'is_re: 0 (ok)',
# 'schema' => [
# 'buf',
# 'is_re',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is_re'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is_re, type, type:buf) is_re: 0 (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 173 - (tags=clause:is_re, type, type:buf) is_re: 0 (ok)
# {
# 'input' => 'a',
# 'name' => 'is_re: 0 (nok)',
# 'schema' => [
# 'buf',
# 'is_re',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:buf',
# 'clause:is_re'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is_re, type, type:buf) is_re: 0 (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 174 - (tags=clause:is_re, type, type:buf) is_re: 0 (nok)
ok 175
1..175
ok 7 - 10-type-buf.json
# Subtest: 10-type-cistr.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => 0,
# 'name' => 'type check: must accept 0',
# 'schema' => 'cistr',
# 'tags' => [
# 'type',
# 'type:cistr'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:cistr) type check: must accept 0
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=type, type:cistr) type check: must accept 0
# {
# 'input' => '1.1',
# 'name' => 'type check: must accept 1.1',
# 'schema' => 'cistr',
# 'tags' => [
# 'type',
# 'type:cistr'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:cistr) type check: must accept 1.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=type, type:cistr) type check: must accept 1.1
# {
# 'input' => '',
# 'name' => 'type check: must accept ',
# 'schema' => 'cistr',
# 'tags' => [
# 'type',
# 'type:cistr'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:cistr) type check: must accept
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 3 - (tags=type, type:cistr) type check: must accept
# {
# 'input' => 'str
# ',
# 'name' => 'type check: must accept str
# ',
# 'schema' => 'cistr',
# 'tags' => [
# 'type',
# 'type:cistr'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:cistr) type check: must accept str
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 4 - (tags=type, type:cistr) type check: must accept str
#
# {
# 'input' => [],
# 'name' => 'type check: must reject []',
# 'schema' => 'cistr',
# 'tags' => [
# 'type',
# 'type:cistr'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:cistr) type check: must reject []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 5 - (tags=type, type:cistr) type check: must reject []
# {
# 'input' => {},
# 'name' => 'type check: must reject {}',
# 'schema' => 'cistr',
# 'tags' => [
# 'type',
# 'type:cistr'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:cistr) type check: must reject {}
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 6 - (tags=type, type:cistr) type check: must reject {}
# {
# 'input' => undef,
# 'name' => 'must accept undefined value',
# 'schema' => 'cistr',
# 'tags' => [
# 'type',
# 'type:cistr'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:cistr) must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 7 - (tags=type, type:cistr) must accept undefined value
# {
# 'input' => undef,
# 'name' => 'defhash_v',
# 'schema' => [
# 'cistr',
# 'defhash_v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:defhash_v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:defhash_v, type, type:cistr) defhash_v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 8 - (tags=clause:defhash_v, type, type:cistr) defhash_v
# {
# 'input' => undef,
# 'name' => 'v',
# 'schema' => [
# 'cistr',
# 'v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:v, type, type:cistr) v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 9 - (tags=clause:v, type, type:cistr) v
# {
# 'input' => undef,
# 'name' => 'c',
# 'schema' => [
# 'cistr',
# 'c.foo.bar',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:c'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:c, type, type:cistr) c
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 10 - (tags=clause:c, type, type:cistr) c
# {
# 'input' => undef,
# 'name' => 'default_lang',
# 'schema' => [
# 'cistr',
# 'default_lang',
# 'id_ID'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:default_lang'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default_lang, type, type:cistr) default_lang
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 11 - (tags=clause:default_lang, type, type:cistr) default_lang
# {
# 'input' => undef,
# 'name' => 'name',
# 'schema' => [
# 'cistr',
# 'name',
# 'some name'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:name'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:name, type, type:cistr) name
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 12 - (tags=clause:name, type, type:cistr) name
# {
# 'input' => undef,
# 'name' => 'summary',
# 'schema' => [
# 'cistr',
# 'summary',
# 'some summary'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:summary'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:summary, type, type:cistr) summary
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 13 - (tags=clause:summary, type, type:cistr) summary
# {
# 'input' => undef,
# 'name' => 'description',
# 'schema' => [
# 'cistr',
# 'description',
# 'some description and `markdown`'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:description'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:description, type, type:cistr) description
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 14 - (tags=clause:description, type, type:cistr) description
# {
# 'input' => undef,
# 'name' => 'tags',
# 'schema' => [
# 'cistr',
# 'tags',
# [
# 'some',
# 'tags'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:tags'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:tags, type, type:cistr) tags
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 15 - (tags=clause:tags, type, type:cistr) tags
# {
# 'input' => undef,
# 'name' => 'req=0 must accept undefined value',
# 'schema' => [
# 'cistr',
# 'req',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:req'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req, type, type:cistr) req=0 must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 16 - (tags=clause:req, type, type:cistr) req=0 must accept undefined value
# {
# 'input' => undef,
# 'name' => 'req=1 must reject undefined value',
# 'schema' => [
# 'cistr',
# 'req',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:req'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:req, type, type:cistr) req=1 must reject undefined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 17 - (tags=clause:req, type, type:cistr) req=1 must reject undefined value
# {
# 'input' => 'a',
# 'name' => 'forbidden=0 must accept defined value',
# 'schema' => [
# 'cistr',
# 'forbidden',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:forbidden'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden, type, type:cistr) forbidden=0 must accept defined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 18 - (tags=clause:forbidden, type, type:cistr) forbidden=0 must accept defined value
# {
# 'input' => 'a',
# 'name' => 'forbidden=1 must reject defined value',
# 'schema' => [
# 'cistr',
# 'forbidden',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:forbidden'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:forbidden, type, type:cistr) forbidden=1 must reject defined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 19 - (tags=clause:forbidden, type, type:cistr) forbidden=1 must reject defined value
# {
# 'input' => undef,
# 'name' => 'default: must accept valid default a',
# 'schema' => [
# 'cistr*',
# 'default',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:default'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default, type, type:cistr) default: must accept valid default a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 20 - (tags=clause:default, type, type:cistr) default: must accept valid default a
# {
# 'input' => undef,
# 'name' => 'default: must reject invalid default []',
# 'schema' => [
# 'cistr*',
# 'default',
# []
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:default'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:default, type, type:cistr) default: must reject invalid default []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 21 - (tags=clause:default, type, type:cistr) default: must reject invalid default []
# {
# 'dies' => 1,
# 'input' => 'a',
# 'name' => 'clause (dies, unknown clause)',
# 'schema' => [
# 'cistr*',
# 'clause',
# [
# 'foo',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:clause'
# ]
# }
# Subtest: (tags=clause:clause, type, type:cistr) clause (dies, unknown clause)
ok 1 - compile error
1..1
ok 22 - (tags=clause:clause, type, type:cistr) clause (dies, unknown clause)
# {
# 'input' => 'a',
# 'name' => 'clause (ok)',
# 'schema' => [
# 'cistr*',
# 'clause',
# [
# 'match',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:clause'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clause, type, type:cistr) clause (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 23 - (tags=clause:clause, type, type:cistr) clause (ok)
# {
# 'input' => 'a',
# 'name' => 'clause (ok) + clause nok = nok',
# 'schema' => [
# 'cistr*',
# 'clause',
# [
# 'match',
# 'a'
# ],
# 'len',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:cistr) clause (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 24 - (tags=clause:clause, type, type:cistr) clause (ok) + clause nok = nok
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'clause (nok)',
# 'schema' => [
# 'cistr*',
# 'clause',
# [
# 'match',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:cistr) clause (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 25 - (tags=clause:clause, type, type:cistr) clause (nok)
# {
# 'dies' => 1,
# 'input' => 'a',
# 'name' => 'clset (dies, unknown clause)',
# 'schema' => [
# 'cistr*',
# 'clset',
# {
# 'foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:cistr) clset (dies, unknown clause)
ok 1 - compile error
1..1
ok 26 - (tags=clause:clset, type, type:cistr) clset (dies, unknown clause)
# {
# 'dies' => 1,
# 'input' => 'a',
# 'name' => 'clset (dies, unknown attr)',
# 'schema' => [
# 'cistr*',
# 'clset',
# {
# 'min_len' => 1,
# 'min_len.foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:cistr) clset (dies, unknown attr)
ok 1 - compile error
1..1
ok 27 - (tags=clause:clset, type, type:cistr) clset (dies, unknown attr)
# {
# 'input' => 'a',
# 'name' => 'clset (empty = ok)',
# 'schema' => [
# 'cistr*',
# 'clset',
# {}
# ],
# 'tags' => [
# 'type',
# 'type:cistr'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:cistr) clset (empty = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 28 - (tags=type, type:cistr) clset (empty = ok)
# {
# 'input' => 'a',
# 'name' => 'clset (ignored clause/attr = ok)',
# 'schema' => [
# 'cistr*',
# 'clset',
# {
# '_foo' => 1,
# 'foo._bar' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:cistr) clset (ignored clause/attr = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 29 - (tags=clause:clset, type, type:cistr) clset (ignored clause/attr = ok)
# {
# 'input' => 'a',
# 'name' => 'clset (ok + ok = ok)',
# 'schema' => [
# 'cistr*',
# 'clset',
# {
# 'len' => 1,
# 'match' => 'a'
# }
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:cistr) clset (ok + ok = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 30 - (tags=clause:clset, type, type:cistr) clset (ok + ok = ok)
# {
# 'input' => 'a',
# 'name' => 'clset (ok) + clause nok = nok',
# 'schema' => [
# 'cistr*',
# 'clset',
# {
# 'match' => 'a'
# },
# 'len',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:cistr) clset (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 31 - (tags=clause:clset, type, type:cistr) clset (ok) + clause nok = nok
# {
# 'input' => 'a',
# 'name' => 'clset (ok + nok = nok)',
# 'schema' => [
# 'cistr*',
# 'clset',
# {
# 'len' => 2,
# 'match' => 'a'
# }
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:cistr) clset (ok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 32 - (tags=clause:clset, type, type:cistr) clset (ok + nok = nok)
# {
# 'input' => 'a',
# 'name' => 'clset (nok + ok = nok)',
# 'schema' => [
# 'cistr*',
# 'clset',
# {
# 'len' => 1,
# 'match' => 'b'
# }
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:cistr) clset (nok + ok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 33 - (tags=clause:clset, type, type:cistr) clset (nok + ok = nok)
# {
# 'input' => 'a',
# 'name' => 'clset (nok + nok = nok)',
# 'schema' => [
# 'cistr*',
# 'clset',
# {
# 'len' => 2,
# 'match' => 'b'
# }
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:cistr) clset (nok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 34 - (tags=clause:clset, type, type:cistr) clset (nok + nok = nok)
# {
# 'input' => undef,
# 'name' => 'ok',
# 'schema' => [
# 'cistr',
# {
# 'ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:ok'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:ok, type, type:cistr) ok
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 35 - (tags=clause:ok, type, type:cistr) ok
# {
# 'input' => undef,
# 'name' => 'ok + op not (nok)',
# 'schema' => [
# 'cistr',
# {
# '!ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:ok',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:ok, op, op:not, type, type:cistr) ok + op not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 36 - (tags=clause:ok, op, op:not, type, type:cistr) ok + op not (nok)
# {
# 'input' => 'a',
# 'name' => '.err_level=error (clause=is, ok)',
# 'schema' => [
# 'cistr',
# 'is',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:cistr) .err_level=error (clause=is, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 37 - (tags=attr, attr:err_level, type, type:cistr) .err_level=error (clause=is, ok)
# {
# 'input' => 'a
# ',
# 'name' => '.err_level=error (clause=is, nok)',
# 'schema' => [
# 'cistr',
# 'is',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 0
# }
# Subtest: (tags=attr, attr:err_level, type, type:cistr) .err_level=error (clause=is, nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 38 - (tags=attr, attr:err_level, type, type:cistr) .err_level=error (clause=is, nok)
# {
# 'input' => 'a',
# 'name' => '.err_level=warn (clause=is, ok)',
# 'schema' => [
# 'cistr',
# 'is',
# 'a',
# 'is.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:cistr) .err_level=warn (clause=is, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 39 - (tags=attr, attr:err_level, type, type:cistr) .err_level=warn (clause=is, ok)
# {
# 'input' => 'a
# ',
# 'name' => '.err_level=warn (clause=is, nok)',
# 'schema' => [
# 'cistr*',
# 'is',
# 'a',
# 'is.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1,
# 'warnings' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:cistr) .err_level=warn (clause=is, nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 40 - (tags=attr, attr:err_level, type, type:cistr) .err_level=warn (clause=is, nok)
# {
# 'input' => 'a',
# 'name' => 'is: must accept same value',
# 'schema' => [
# 'cistr',
# 'is',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, type, type:cistr) is: must accept same value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 41 - (tags=clause:is, type, type:cistr) is: must accept same value
# {
# 'input' => 'a',
# 'name' => 'is: must reject different value',
# 'schema' => [
# 'cistr',
# 'is',
# 'B'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, type, type:cistr) is: must reject different value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 42 - (tags=clause:is, type, type:cistr) is: must reject different value
# {
# 'input' => 'a',
# 'name' => '!is (nok)',
# 'schema' => [
# 'cistr',
# '!is',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:cistr) !is (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 43 - (tags=clause:is, op, op:not, opshortcut, type, type:cistr) !is (nok)
# {
# 'input' => 'a',
# 'name' => '!is (ok)',
# 'schema' => [
# 'cistr',
# '!is',
# 'B'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:cistr) !is (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 44 - (tags=clause:is, op, op:not, opshortcut, type, type:cistr) !is (ok)
# {
# 'input' => 'a',
# 'name' => 'is.op=not (nok)',
# 'schema' => [
# 'cistr',
# 'is',
# 'a',
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, type, type:cistr) is.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 45 - (tags=clause:is, op, op:not, type, type:cistr) is.op=not (nok)
# {
# 'input' => 'a',
# 'name' => 'is.op=not (ok)',
# 'schema' => [
# 'cistr',
# 'is',
# 'B',
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, type, type:cistr) is.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 46 - (tags=clause:is, op, op:not, type, type:cistr) is.op=not (ok)
# {
# 'input' => 'a',
# 'name' => 'is& (no items)',
# 'schema' => [
# 'cistr',
# 'is&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:cistr) is& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 47 - (tags=clause:is, op, op:and, opshortcut, type, type:cistr) is& (no items)
# {
# 'input' => 'a',
# 'name' => 'is& (ok)',
# 'schema' => [
# 'cistr',
# 'is&',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:cistr) is& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 48 - (tags=clause:is, op, op:and, opshortcut, type, type:cistr) is& (ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is& (nok + ok)',
# 'schema' => [
# 'cistr',
# 'is&',
# [
# 'B',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:cistr) is& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 49 - (tags=clause:is, op, op:and, opshortcut, type, type:cistr) is& (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is& (ok + nok)',
# 'schema' => [
# 'cistr',
# 'is&',
# [
# 'a',
# 'B'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:cistr) is& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 50 - (tags=clause:is, op, op:and, opshortcut, type, type:cistr) is& (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is& (nok + nok)',
# 'schema' => [
# 'cistr',
# 'is&',
# [
# 'B',
# 'B'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:cistr) is& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 51 - (tags=clause:is, op, op:and, opshortcut, type, type:cistr) is& (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'is.op=and (no items)',
# 'schema' => [
# 'cistr',
# 'is',
# [],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:cistr) is.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 52 - (tags=type, type:cistr) is.op=and (no items)
# {
# 'input' => 'a',
# 'name' => 'is.op=and (ok)',
# 'schema' => [
# 'cistr',
# 'is',
# [
# 'a',
# 'a'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, type, type:cistr) is.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 53 - (tags=clause:is, op, op:and, type, type:cistr) is.op=and (ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=and (nok + ok)',
# 'schema' => [
# 'cistr',
# 'is',
# [
# 'B',
# 'a'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:cistr) is.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 54 - (tags=clause:is, op, op:and, type, type:cistr) is.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=and (ok + nok)',
# 'schema' => [
# 'cistr',
# 'is',
# [
# 'a',
# 'B'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:cistr) is.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 55 - (tags=clause:is, op, op:and, type, type:cistr) is.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=and (nok + nok)',
# 'schema' => [
# 'cistr',
# 'is',
# [
# 'B',
# 'B'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:cistr) is.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 56 - (tags=clause:is, op, op:and, type, type:cistr) is.op=and (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'is| (no items)',
# 'schema' => [
# 'cistr',
# 'is|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:cistr) is| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 57 - (tags=clause:is, op, op:or, opshortcut, type, type:cistr) is| (no items)
# {
# 'input' => 'a',
# 'name' => 'is| (ok)',
# 'schema' => [
# 'cistr',
# 'is|',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:cistr) is| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 58 - (tags=clause:is, op, op:or, opshortcut, type, type:cistr) is| (ok)
# {
# 'input' => 'a',
# 'name' => 'is| (nok + ok)',
# 'schema' => [
# 'cistr',
# 'is|',
# [
# 'B',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:cistr) is| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 59 - (tags=clause:is, op, op:or, opshortcut, type, type:cistr) is| (nok + ok)
# {
# 'input' => 'a',
# 'name' => 'is| (ok + nok)',
# 'schema' => [
# 'cistr',
# 'is|',
# [
# 'a',
# 'B'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:cistr) is| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 60 - (tags=clause:is, op, op:or, opshortcut, type, type:cistr) is| (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is| (nok + nok)',
# 'schema' => [
# 'cistr',
# 'is|',
# [
# 'B',
# 'B'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:cistr) is| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 61 - (tags=clause:is, op, op:or, opshortcut, type, type:cistr) is| (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'is.op=or (no items)',
# 'schema' => [
# 'cistr',
# 'is',
# [],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:cistr) is.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 62 - (tags=clause:is, op, op:or, type, type:cistr) is.op=or (no items)
# {
# 'input' => 'a',
# 'name' => 'is.op=or (ok)',
# 'schema' => [
# 'cistr',
# 'is',
# [
# 'a',
# 'a'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:cistr) is.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 63 - (tags=clause:is, op, op:or, type, type:cistr) is.op=or (ok)
# {
# 'input' => 'a',
# 'name' => 'is.op=or (nok + ok)',
# 'schema' => [
# 'cistr',
# 'is',
# [
# 'B',
# 'a'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:cistr) is.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 64 - (tags=clause:is, op, op:or, type, type:cistr) is.op=or (nok + ok)
# {
# 'input' => 'a',
# 'name' => 'is.op=or (ok + nok)',
# 'schema' => [
# 'cistr',
# 'is',
# [
# 'a',
# 'B'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:cistr) is.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 65 - (tags=clause:is, op, op:or, type, type:cistr) is.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=or (nok + nok)',
# 'schema' => [
# 'cistr',
# 'is',
# [
# 'B',
# 'B'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, type, type:cistr) is.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 66 - (tags=clause:is, op, op:or, type, type:cistr) is.op=or (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'is.op=none (empty items)',
# 'schema' => [
# 'cistr',
# 'is',
# [],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:cistr) is.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 67 - (tags=clause:is, op, op:none, type, type:cistr) is.op=none (empty items)
# {
# 'input' => 'a',
# 'name' => 'is.op=none (nok + nok)',
# 'schema' => [
# 'cistr',
# 'is',
# [
# 'B',
# 'B'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:cistr) is.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 68 - (tags=clause:is, op, op:none, type, type:cistr) is.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=none (nok + ok)',
# 'schema' => [
# 'cistr',
# 'is',
# [
# 'B',
# 'a'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:cistr) is.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 69 - (tags=clause:is, op, op:none, type, type:cistr) is.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=none (ok + nok)',
# 'schema' => [
# 'cistr',
# 'is',
# [
# 'a',
# 'B'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:cistr) is.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 70 - (tags=clause:is, op, op:none, type, type:cistr) is.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=none (ok + ok)',
# 'schema' => [
# 'cistr',
# 'is',
# [
# 'a',
# 'a'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:cistr) is.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 71 - (tags=clause:is, op, op:none, type, type:cistr) is.op=none (ok + ok)
# {
# 'input' => 'a',
# 'name' => 'in: must accept valid choices',
# 'schema' => [
# 'cistr',
# 'in',
# [
# 'a',
# 'B'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, type, type:cistr) in: must accept valid choices
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 72 - (tags=clause:in, type, type:cistr) in: must accept valid choices
# {
# 'input' => 'a',
# 'name' => 'in: must reject empty choices',
# 'schema' => [
# 'cistr',
# 'in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, type, type:cistr) in: must reject empty choices
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 73 - (tags=clause:in, type, type:cistr) in: must reject empty choices
# {
# 'input' => 'a',
# 'name' => '!in (nok)',
# 'schema' => [
# 'cistr',
# '!in',
# [
# 'a',
# 'B'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:cistr) !in (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 74 - (tags=clause:in, op, op:not, opshortcut, type, type:cistr) !in (nok)
# {
# 'input' => 'a',
# 'name' => '!in (ok)',
# 'schema' => [
# 'cistr',
# '!in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:cistr) !in (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 75 - (tags=clause:in, op, op:not, opshortcut, type, type:cistr) !in (ok)
# {
# 'input' => 'a',
# 'name' => 'in.op=not (nok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# 'a',
# 'B'
# ],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, type, type:cistr) in.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 76 - (tags=clause:in, op, op:not, type, type:cistr) in.op=not (nok)
# {
# 'input' => 'a',
# 'name' => 'in.op=not (ok)',
# 'schema' => [
# 'cistr',
# 'in',
# [],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, type, type:cistr) in.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 77 - (tags=clause:in, op, op:not, type, type:cistr) in.op=not (ok)
# {
# 'input' => 'a',
# 'name' => 'in& (no items)',
# 'schema' => [
# 'cistr',
# 'in&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:cistr) in& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 78 - (tags=clause:in, op, op:and, opshortcut, type, type:cistr) in& (no items)
# {
# 'input' => 'a',
# 'name' => 'in& (ok)',
# 'schema' => [
# 'cistr',
# 'in&',
# [
# [
# 'a',
# 'B'
# ],
# [
# 'a',
# 'B'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:cistr) in& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 79 - (tags=clause:in, op, op:and, opshortcut, type, type:cistr) in& (ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in& (nok + ok)',
# 'schema' => [
# 'cistr',
# 'in&',
# [
# [],
# [
# 'a',
# 'B'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:cistr) in& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 80 - (tags=clause:in, op, op:and, opshortcut, type, type:cistr) in& (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in& (ok + nok)',
# 'schema' => [
# 'cistr',
# 'in&',
# [
# [
# 'a',
# 'B'
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:cistr) in& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 81 - (tags=clause:in, op, op:and, opshortcut, type, type:cistr) in& (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in& (nok + nok)',
# 'schema' => [
# 'cistr',
# 'in&',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:cistr) in& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 82 - (tags=clause:in, op, op:and, opshortcut, type, type:cistr) in& (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'in.op=and (no items)',
# 'schema' => [
# 'cistr',
# 'in',
# [],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:cistr) in.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 83 - (tags=type, type:cistr) in.op=and (no items)
# {
# 'input' => 'a',
# 'name' => 'in.op=and (ok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# [
# 'a',
# 'B'
# ],
# [
# 'a',
# 'B'
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, type, type:cistr) in.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 84 - (tags=clause:in, op, op:and, type, type:cistr) in.op=and (ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=and (nok + ok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# [],
# [
# 'a',
# 'B'
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:cistr) in.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 85 - (tags=clause:in, op, op:and, type, type:cistr) in.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=and (ok + nok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# [
# 'a',
# 'B'
# ],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:cistr) in.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 86 - (tags=clause:in, op, op:and, type, type:cistr) in.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=and (nok + nok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:cistr) in.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 87 - (tags=clause:in, op, op:and, type, type:cistr) in.op=and (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'in| (no items)',
# 'schema' => [
# 'cistr',
# 'in|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:cistr) in| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 88 - (tags=clause:in, op, op:or, opshortcut, type, type:cistr) in| (no items)
# {
# 'input' => 'a',
# 'name' => 'in| (ok)',
# 'schema' => [
# 'cistr',
# 'in|',
# [
# [
# 'a',
# 'B'
# ],
# [
# 'a',
# 'B'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:cistr) in| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 89 - (tags=clause:in, op, op:or, opshortcut, type, type:cistr) in| (ok)
# {
# 'input' => 'a',
# 'name' => 'in| (nok + ok)',
# 'schema' => [
# 'cistr',
# 'in|',
# [
# [],
# [
# 'a',
# 'B'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:cistr) in| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 90 - (tags=clause:in, op, op:or, opshortcut, type, type:cistr) in| (nok + ok)
# {
# 'input' => 'a',
# 'name' => 'in| (ok + nok)',
# 'schema' => [
# 'cistr',
# 'in|',
# [
# [
# 'a',
# 'B'
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:cistr) in| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 91 - (tags=clause:in, op, op:or, opshortcut, type, type:cistr) in| (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in| (nok + nok)',
# 'schema' => [
# 'cistr',
# 'in|',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:cistr) in| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 92 - (tags=clause:in, op, op:or, opshortcut, type, type:cistr) in| (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'in.op=or (no items)',
# 'schema' => [
# 'cistr',
# 'in',
# [],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:cistr) in.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 93 - (tags=clause:in, op, op:or, type, type:cistr) in.op=or (no items)
# {
# 'input' => 'a',
# 'name' => 'in.op=or (ok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# [
# 'a',
# 'B'
# ],
# [
# 'a',
# 'B'
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:cistr) in.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 94 - (tags=clause:in, op, op:or, type, type:cistr) in.op=or (ok)
# {
# 'input' => 'a',
# 'name' => 'in.op=or (nok + ok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# [],
# [
# 'a',
# 'B'
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:cistr) in.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 95 - (tags=clause:in, op, op:or, type, type:cistr) in.op=or (nok + ok)
# {
# 'input' => 'a',
# 'name' => 'in.op=or (ok + nok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# [
# 'a',
# 'B'
# ],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:cistr) in.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 96 - (tags=clause:in, op, op:or, type, type:cistr) in.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=or (nok + nok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, type, type:cistr) in.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 97 - (tags=clause:in, op, op:or, type, type:cistr) in.op=or (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'in.op=none (empty items)',
# 'schema' => [
# 'cistr',
# 'in',
# [],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:cistr) in.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 98 - (tags=clause:in, op, op:none, type, type:cistr) in.op=none (empty items)
# {
# 'input' => 'a',
# 'name' => 'in.op=none (nok + nok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:cistr) in.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 99 - (tags=clause:in, op, op:none, type, type:cistr) in.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=none (nok + ok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# [],
# [
# 'a',
# 'B'
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:cistr) in.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 100 - (tags=clause:in, op, op:none, type, type:cistr) in.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=none (ok + nok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# [
# 'a',
# 'B'
# ],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:cistr) in.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 101 - (tags=clause:in, op, op:none, type, type:cistr) in.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=none (ok + ok)',
# 'schema' => [
# 'cistr',
# 'in',
# [
# [
# 'a',
# 'B'
# ],
# [
# 'a',
# 'B'
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:cistr) in.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 102 - (tags=clause:in, op, op:none, type, type:cistr) in.op=none (ok + ok)
# {
# 'input' => 'a',
# 'name' => 'min: a ',
# 'schema' => [
# 'cistr',
# 'min',
# ''
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:cistr) min: a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 103 - (tags=clause:min, type, type:cistr) min: a
# {
# 'input' => 'a',
# 'name' => 'min: a a',
# 'schema' => [
# 'cistr',
# 'min',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:cistr) min: a a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 104 - (tags=clause:min, type, type:cistr) min: a a
# {
# 'input' => '',
# 'name' => 'min: a -> fail',
# 'schema' => [
# 'cistr',
# 'min',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:min'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:min, type, type:cistr) min: a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 105 - (tags=clause:min, type, type:cistr) min: a -> fail
# {
# 'input' => 'a',
# 'name' => 'xmin: a ',
# 'schema' => [
# 'cistr',
# 'xmin',
# ''
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:xmin'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmin, type, type:cistr) xmin: a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 106 - (tags=clause:xmin, type, type:cistr) xmin: a
# {
# 'input' => 'a',
# 'name' => 'xmin: a a -> fail',
# 'schema' => [
# 'cistr',
# 'xmin',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:cistr) xmin: a a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 107 - (tags=clause:xmin, type, type:cistr) xmin: a a -> fail
# {
# 'input' => '',
# 'name' => 'xmin: a -> fail',
# 'schema' => [
# 'cistr',
# 'xmin',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:cistr) xmin: a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 108 - (tags=clause:xmin, type, type:cistr) xmin: a -> fail
# {
# 'input' => 'a',
# 'name' => 'max: a -> fail',
# 'schema' => [
# 'cistr',
# 'max',
# ''
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:max'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:max, type, type:cistr) max: a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 109 - (tags=clause:max, type, type:cistr) max: a -> fail
# {
# 'input' => 'a',
# 'name' => 'max: a a',
# 'schema' => [
# 'cistr',
# 'max',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:cistr) max: a a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 110 - (tags=clause:max, type, type:cistr) max: a a
# {
# 'input' => '',
# 'name' => 'max: a',
# 'schema' => [
# 'cistr',
# 'max',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:cistr) max: a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 111 - (tags=clause:max, type, type:cistr) max: a
# {
# 'input' => 'a',
# 'name' => 'xmax: a -> fail',
# 'schema' => [
# 'cistr',
# 'xmax',
# ''
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:cistr) xmax: a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 112 - (tags=clause:xmax, type, type:cistr) xmax: a -> fail
# {
# 'input' => 'a',
# 'name' => 'xmax: a a -> fail',
# 'schema' => [
# 'cistr',
# 'xmax',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:cistr) xmax: a a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 113 - (tags=clause:xmax, type, type:cistr) xmax: a a -> fail
# {
# 'input' => '',
# 'name' => 'xmax: a',
# 'schema' => [
# 'cistr',
# 'xmax',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:xmax'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmax, type, type:cistr) xmax: a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 114 - (tags=clause:xmax, type, type:cistr) xmax: a
# {
# 'input' => 'a',
# 'name' => 'between: a & Ab',
# 'schema' => [
# 'cistr',
# 'between',
# [
# '',
# 'Ab'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:cistr) between: a & Ab
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 115 - (tags=clause:between, type, type:cistr) between: a & Ab
# {
# 'input' => 'a',
# 'name' => 'between: a & a',
# 'schema' => [
# 'cistr',
# 'between',
# [
# '',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:cistr) between: a & a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 116 - (tags=clause:between, type, type:cistr) between: a & a
# {
# 'input' => 'a',
# 'name' => 'between: a a & a',
# 'schema' => [
# 'cistr',
# 'between',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:cistr) between: a a & a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 117 - (tags=clause:between, type, type:cistr) between: a a & a
# {
# 'input' => '',
# 'name' => 'between: a & Ab -> fail',
# 'schema' => [
# 'cistr',
# 'between',
# [
# 'a',
# 'Ab'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, type, type:cistr) between: a & Ab -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 118 - (tags=clause:between, type, type:cistr) between: a & Ab -> fail
# {
# 'input' => 'a',
# 'name' => 'xbetween: a & Ab',
# 'schema' => [
# 'cistr',
# 'xbetween',
# [
# '',
# 'Ab'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:xbetween'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xbetween, type, type:cistr) xbetween: a & Ab
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 119 - (tags=clause:xbetween, type, type:cistr) xbetween: a & Ab
# {
# 'input' => 'a',
# 'name' => 'xbetween: a & a -> fail',
# 'schema' => [
# 'cistr',
# 'xbetween',
# [
# '',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:cistr) xbetween: a & a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 120 - (tags=clause:xbetween, type, type:cistr) xbetween: a & a -> fail
# {
# 'input' => 'a',
# 'name' => 'xbetween: a a & a -> fail',
# 'schema' => [
# 'cistr',
# 'xbetween',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:cistr) xbetween: a a & a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 121 - (tags=clause:xbetween, type, type:cistr) xbetween: a a & a -> fail
# {
# 'input' => '',
# 'name' => 'xbetween: a & Ab -> fail',
# 'schema' => [
# 'cistr',
# 'xbetween',
# [
# 'a',
# 'Ab'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:cistr) xbetween: a & Ab -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 122 - (tags=clause:xbetween, type, type:cistr) xbetween: a & Ab -> fail
# {
# 'input' => '',
# 'name' => '!between (nok)',
# 'schema' => [
# 'cistr',
# '!between',
# [
# '',
# ''
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:not, opshortcut, type, type:cistr) !between (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 123 - (tags=clause:between, op, op:not, opshortcut, type, type:cistr) !between (nok)
# {
# 'input' => '',
# 'name' => '!between (ok)',
# 'schema' => [
# 'cistr',
# '!between',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:not, opshortcut, type, type:cistr) !between (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 124 - (tags=clause:between, op, op:not, opshortcut, type, type:cistr) !between (ok)
# {
# 'input' => '',
# 'name' => 'between.op=not (nok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# '',
# ''
# ],
# 'between.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:not, type, type:cistr) between.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 125 - (tags=clause:between, op, op:not, type, type:cistr) between.op=not (nok)
# {
# 'input' => '',
# 'name' => 'between.op=not (ok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# 'a',
# 'a'
# ],
# 'between.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:not, type, type:cistr) between.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 126 - (tags=clause:between, op, op:not, type, type:cistr) between.op=not (ok)
# {
# 'input' => '',
# 'name' => 'between& (no items)',
# 'schema' => [
# 'cistr',
# 'between&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:cistr) between& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 127 - (tags=clause:between, op, op:and, opshortcut, type, type:cistr) between& (no items)
# {
# 'input' => '',
# 'name' => 'between& (ok)',
# 'schema' => [
# 'cistr',
# 'between&',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:cistr) between& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 128 - (tags=clause:between, op, op:and, opshortcut, type, type:cistr) between& (ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between& (nok + ok)',
# 'schema' => [
# 'cistr',
# 'between&',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:cistr) between& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 129 - (tags=clause:between, op, op:and, opshortcut, type, type:cistr) between& (nok + ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between& (ok + nok)',
# 'schema' => [
# 'cistr',
# 'between&',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:cistr) between& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 130 - (tags=clause:between, op, op:and, opshortcut, type, type:cistr) between& (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between& (nok + nok)',
# 'schema' => [
# 'cistr',
# 'between&',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:cistr) between& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 131 - (tags=clause:between, op, op:and, opshortcut, type, type:cistr) between& (nok + nok)
# {
# 'input' => '',
# 'name' => 'between.op=and (no items)',
# 'schema' => [
# 'cistr',
# 'between',
# [],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:cistr) between.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 132 - (tags=type, type:cistr) between.op=and (no items)
# {
# 'input' => '',
# 'name' => 'between.op=and (ok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, type, type:cistr) between.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 133 - (tags=clause:between, op, op:and, type, type:cistr) between.op=and (ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=and (nok + ok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:cistr) between.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 134 - (tags=clause:between, op, op:and, type, type:cistr) between.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=and (ok + nok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:cistr) between.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 135 - (tags=clause:between, op, op:and, type, type:cistr) between.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=and (nok + nok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:cistr) between.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 136 - (tags=clause:between, op, op:and, type, type:cistr) between.op=and (nok + nok)
# {
# 'input' => '',
# 'name' => 'between| (no items)',
# 'schema' => [
# 'cistr',
# 'between|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:cistr) between| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 137 - (tags=clause:between, op, op:or, opshortcut, type, type:cistr) between| (no items)
# {
# 'input' => '',
# 'name' => 'between| (ok)',
# 'schema' => [
# 'cistr',
# 'between|',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:cistr) between| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 138 - (tags=clause:between, op, op:or, opshortcut, type, type:cistr) between| (ok)
# {
# 'input' => '',
# 'name' => 'between| (nok + ok)',
# 'schema' => [
# 'cistr',
# 'between|',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:cistr) between| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 139 - (tags=clause:between, op, op:or, opshortcut, type, type:cistr) between| (nok + ok)
# {
# 'input' => '',
# 'name' => 'between| (ok + nok)',
# 'schema' => [
# 'cistr',
# 'between|',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:cistr) between| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 140 - (tags=clause:between, op, op:or, opshortcut, type, type:cistr) between| (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between| (nok + nok)',
# 'schema' => [
# 'cistr',
# 'between|',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:cistr) between| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 141 - (tags=clause:between, op, op:or, opshortcut, type, type:cistr) between| (nok + nok)
# {
# 'input' => '',
# 'name' => 'between.op=or (no items)',
# 'schema' => [
# 'cistr',
# 'between',
# [],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:cistr) between.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 142 - (tags=clause:between, op, op:or, type, type:cistr) between.op=or (no items)
# {
# 'input' => '',
# 'name' => 'between.op=or (ok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:cistr) between.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 143 - (tags=clause:between, op, op:or, type, type:cistr) between.op=or (ok)
# {
# 'input' => '',
# 'name' => 'between.op=or (nok + ok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:cistr) between.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 144 - (tags=clause:between, op, op:or, type, type:cistr) between.op=or (nok + ok)
# {
# 'input' => '',
# 'name' => 'between.op=or (ok + nok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:cistr) between.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 145 - (tags=clause:between, op, op:or, type, type:cistr) between.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=or (nok + nok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:or, type, type:cistr) between.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 146 - (tags=clause:between, op, op:or, type, type:cistr) between.op=or (nok + nok)
# {
# 'input' => '',
# 'name' => 'between.op=none (empty items)',
# 'schema' => [
# 'cistr',
# 'between',
# [],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:none, type, type:cistr) between.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 147 - (tags=clause:between, op, op:none, type, type:cistr) between.op=none (empty items)
# {
# 'input' => '',
# 'name' => 'between.op=none (nok + nok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:none, type, type:cistr) between.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 148 - (tags=clause:between, op, op:none, type, type:cistr) between.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=none (nok + ok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:cistr) between.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 149 - (tags=clause:between, op, op:none, type, type:cistr) between.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=none (ok + nok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:cistr) between.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 150 - (tags=clause:between, op, op:none, type, type:cistr) between.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=none (ok + ok)',
# 'schema' => [
# 'cistr',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:cistr) between.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 151 - (tags=clause:between, op, op:none, type, type:cistr) between.op=none (ok + ok)
# {
# 'input' => 'a',
# 'name' => 'len (ok)',
# 'schema' => [
# 'cistr',
# 'len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:len, type, type:cistr) len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 152 - (tags=clause:len, type, type:cistr) len (ok)
# {
# 'input' => 'a',
# 'name' => 'len (nok)',
# 'schema' => [
# 'cistr',
# 'len',
# 3
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:len, type, type:cistr) len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 153 - (tags=clause:len, type, type:cistr) len (nok)
# {
# 'input' => 'a',
# 'name' => 'min_len (ok)',
# 'schema' => [
# 'cistr',
# 'min_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:min_len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min_len, type, type:cistr) min_len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 154 - (tags=clause:min_len, type, type:cistr) min_len (ok)
# {
# 'input' => 'a',
# 'name' => 'min_len (nok)',
# 'schema' => [
# 'cistr',
# 'min_len',
# 3
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:min_len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:min_len, type, type:cistr) min_len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 155 - (tags=clause:min_len, type, type:cistr) min_len (nok)
# {
# 'input' => 'a',
# 'name' => 'max_len (ok)',
# 'schema' => [
# 'cistr',
# 'min_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:max_len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max_len, type, type:cistr) max_len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 156 - (tags=clause:max_len, type, type:cistr) max_len (ok)
# {
# 'input' => 'abc',
# 'name' => 'max_len (nok)',
# 'schema' => [
# 'cistr',
# 'max_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:max_len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:max_len, type, type:cistr) max_len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 157 - (tags=clause:max_len, type, type:cistr) max_len (nok)
# {
# 'input' => 'a',
# 'name' => 'len_between (ok)',
# 'schema' => [
# 'cistr',
# 'len_between',
# [
# 1,
# 3
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:len_between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:len_between, type, type:cistr) len_between (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 158 - (tags=clause:len_between, type, type:cistr) len_between (ok)
# {
# 'input' => 'abc',
# 'name' => 'len_between (nok)',
# 'schema' => [
# 'cistr',
# 'len_between',
# [
# 1,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:len_between'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:len_between, type, type:cistr) len_between (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 159 - (tags=clause:len_between, type, type:cistr) len_between (nok)
# {
# 'input' => 'abc',
# 'name' => 'each_index (ok)',
# 'schema' => [
# 'cistr',
# 'each_index',
# [
# 'int',
# 'max',
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:each_index'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:each_index, type, type:cistr) each_index (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 160 - (tags=clause:each_index, type, type:cistr) each_index (ok)
# {
# 'input' => 'abc',
# 'name' => 'each_index (nok)',
# 'schema' => [
# 'cistr',
# 'each_index',
# [
# 'int',
# 'xmax',
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:each_index'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:each_index, type, type:cistr) each_index (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 161 - (tags=clause:each_index, type, type:cistr) each_index (nok)
# {
# 'input' => 'abc',
# 'name' => 'each_elem (ok)',
# 'schema' => [
# 'cistr',
# 'each_elem',
# 'cistr'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:each_elem'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:each_elem, type, type:cistr) each_elem (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 162 - (tags=clause:each_elem, type, type:cistr) each_elem (ok)
# {
# 'input' => 'abc',
# 'name' => 'each_elem (nok)',
# 'schema' => [
# 'cistr',
# 'each_elem',
# 'float'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:each_elem'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:each_elem, type, type:cistr) each_elem (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 163 - (tags=clause:each_elem, type, type:cistr) each_elem (nok)
# {
# 'invalid_inputs' => [
# '',
# 'c'
# ],
# 'name' => 'has',
# 'schema' => [
# 'cistr',
# 'has',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:has'
# ],
# 'valid_inputs' => [
# 'abc',
# 'Ac'
# ]
# }
# Subtest: (tags=clause:has, type, type:cistr) has
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - validator (rt=full) returns hash
1..6
ok 164 - (tags=clause:has, type, type:cistr) has
# {
# 'invalid_inputs' => [
# 'abc',
# 'Ac'
# ],
# 'name' => 'has + op.not',
# 'schema' => [
# 'cistr',
# '!has',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:has',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# '',
# 'c'
# ]
# }
# Subtest: (tags=clause:has, op, op:not, opshortcut, type, type:cistr) has + op.not
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - validator (rt=full) returns hash
1..6
ok 165 - (tags=clause:has, op, op:not, opshortcut, type, type:cistr) has + op.not
# {
# 'invalid_inputs' => [
# '',
# 'c'
# ],
# 'name' => 'has + op.or',
# 'schema' => [
# 'cistr',
# 'has|',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:has',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# 'abc',
# 'Ac'
# ]
# }
# Subtest: (tags=clause:has, op, op:or, opshortcut, type, type:cistr) has + op.or
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - validator (rt=full) returns hash
1..6
ok 166 - (tags=clause:has, op, op:or, opshortcut, type, type:cistr) has + op.or
# {
# 'invalid_inputs' => [
# 'Ac',
# '',
# 'c'
# ],
# 'name' => 'has + op.and',
# 'schema' => [
# 'cistr',
# 'has&',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:has',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# 'abc'
# ]
# }
# Subtest: (tags=clause:has, op, op:and, opshortcut, type, type:cistr) has + op.and
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - invalid input [0]
ok 4 - invalid input [1]
ok 5 - invalid input [2]
ok 6 - validator (rt=full) returns hash
1..6
ok 167 - (tags=clause:has, op, op:and, opshortcut, type, type:cistr) has + op.and
# {
# 'input' => 'A',
# 'name' => 'match: (ok)',
# 'schema' => [
# 'cistr',
# 'match',
# '[abc]'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:match'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:match, type, type:cistr) match: (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 168 - (tags=clause:match, type, type:cistr) match: (ok)
# {
# 'input' => 'z',
# 'name' => 'match: (nok)',
# 'schema' => [
# 'cistr',
# 'match',
# '[abc]'
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:match'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:match, type, type:cistr) match: (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 169 - (tags=clause:match, type, type:cistr) match: (nok)
# {
# 'dies' => 1,
# 'input' => 'a',
# 'name' => 'match: (dies, invalid regex)',
# 'schema' => [
# 'cistr',
# 'match',
# '('
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:match'
# ]
# }
# Subtest: (tags=clause:match, type, type:cistr) match: (dies, invalid regex)
ok 1 - compile error
1..1
ok 170 - (tags=clause:match, type, type:cistr) match: (dies, invalid regex)
# {
# 'input' => 'a',
# 'name' => 'is_re: 1 (ok)',
# 'schema' => [
# 'cistr',
# 'is_re',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is_re'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is_re, type, type:cistr) is_re: 1 (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 171 - (tags=clause:is_re, type, type:cistr) is_re: 1 (ok)
# {
# 'input' => 'a(',
# 'name' => 'is_re: 1 (nok)',
# 'schema' => [
# 'cistr',
# 'is_re',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is_re'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is_re, type, type:cistr) is_re: 1 (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 172 - (tags=clause:is_re, type, type:cistr) is_re: 1 (nok)
# {
# 'input' => 'a(',
# 'name' => 'is_re: 0 (ok)',
# 'schema' => [
# 'cistr',
# 'is_re',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is_re'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is_re, type, type:cistr) is_re: 0 (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 173 - (tags=clause:is_re, type, type:cistr) is_re: 0 (ok)
# {
# 'input' => 'a',
# 'name' => 'is_re: 0 (nok)',
# 'schema' => [
# 'cistr',
# 'is_re',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:cistr',
# 'clause:is_re'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is_re, type, type:cistr) is_re: 0 (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 174 - (tags=clause:is_re, type, type:cistr) is_re: 0 (nok)
ok 175
1..175
ok 8 - 10-type-cistr.json
# Subtest: 10-type-float.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => '-1.1',
# 'name' => 'type check: must accept -1.1',
# 'schema' => 'float',
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:float) type check: must accept -1.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=type, type:float) type check: must accept -1.1
# {
# 'input' => -1,
# 'name' => 'type check: must accept -1',
# 'schema' => 'float',
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:float) type check: must accept -1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=type, type:float) type check: must accept -1
# {
# 'input' => 0,
# 'name' => 'type check: must accept 0',
# 'schema' => 'float',
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:float) type check: must accept 0
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 3 - (tags=type, type:float) type check: must accept 0
# {
# 'input' => 1,
# 'name' => 'type check: must accept 1',
# 'schema' => 'float',
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:float) type check: must accept 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 4 - (tags=type, type:float) type check: must accept 1
# {
# 'input' => '1.1',
# 'name' => 'type check: must accept 1.1',
# 'schema' => 'float',
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:float) type check: must accept 1.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 5 - (tags=type, type:float) type check: must accept 1.1
# {
# 'input' => 'a',
# 'name' => 'type check: must reject a',
# 'schema' => 'float',
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:float) type check: must reject a
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 6 - (tags=type, type:float) type check: must reject a
# {
# 'input' => [],
# 'name' => 'type check: must reject []',
# 'schema' => 'float',
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:float) type check: must reject []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 7 - (tags=type, type:float) type check: must reject []
# {
# 'input' => {},
# 'name' => 'type check: must reject {}',
# 'schema' => 'float',
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:float) type check: must reject {}
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 8 - (tags=type, type:float) type check: must reject {}
# {
# 'input' => undef,
# 'name' => 'must accept undefined value',
# 'schema' => 'float',
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:float) must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 9 - (tags=type, type:float) must accept undefined value
# {
# 'input' => undef,
# 'name' => 'defhash_v',
# 'schema' => [
# 'float',
# 'defhash_v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:defhash_v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:defhash_v, type, type:float) defhash_v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 10 - (tags=clause:defhash_v, type, type:float) defhash_v
# {
# 'input' => undef,
# 'name' => 'v',
# 'schema' => [
# 'float',
# 'v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:v, type, type:float) v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 11 - (tags=clause:v, type, type:float) v
# {
# 'input' => undef,
# 'name' => 'c',
# 'schema' => [
# 'float',
# 'c.foo.bar',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:c'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:c, type, type:float) c
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 12 - (tags=clause:c, type, type:float) c
# {
# 'input' => undef,
# 'name' => 'default_lang',
# 'schema' => [
# 'float',
# 'default_lang',
# 'id_ID'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:default_lang'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default_lang, type, type:float) default_lang
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 13 - (tags=clause:default_lang, type, type:float) default_lang
# {
# 'input' => undef,
# 'name' => 'name',
# 'schema' => [
# 'float',
# 'name',
# 'some name'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:name'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:name, type, type:float) name
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 14 - (tags=clause:name, type, type:float) name
# {
# 'input' => undef,
# 'name' => 'summary',
# 'schema' => [
# 'float',
# 'summary',
# 'some summary'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:summary'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:summary, type, type:float) summary
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 15 - (tags=clause:summary, type, type:float) summary
# {
# 'input' => undef,
# 'name' => 'description',
# 'schema' => [
# 'float',
# 'description',
# 'some description and `markdown`'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:description'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:description, type, type:float) description
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 16 - (tags=clause:description, type, type:float) description
# {
# 'input' => undef,
# 'name' => 'tags',
# 'schema' => [
# 'float',
# 'tags',
# [
# 'some',
# 'tags'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:tags'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:tags, type, type:float) tags
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 17 - (tags=clause:tags, type, type:float) tags
# {
# 'input' => undef,
# 'name' => 'req=0 must accept undefined value',
# 'schema' => [
# 'float',
# 'req',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:req'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req, type, type:float) req=0 must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 18 - (tags=clause:req, type, type:float) req=0 must accept undefined value
# {
# 'input' => undef,
# 'name' => 'req=1 must reject undefined value',
# 'schema' => [
# 'float',
# 'req',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:req'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:req, type, type:float) req=1 must reject undefined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 19 - (tags=clause:req, type, type:float) req=1 must reject undefined value
# {
# 'input' => '1.1',
# 'name' => 'forbidden=0 must accept defined value',
# 'schema' => [
# 'float',
# 'forbidden',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:forbidden'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden, type, type:float) forbidden=0 must accept defined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 20 - (tags=clause:forbidden, type, type:float) forbidden=0 must accept defined value
# {
# 'input' => '1.1',
# 'name' => 'forbidden=1 must reject defined value',
# 'schema' => [
# 'float',
# 'forbidden',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:forbidden'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:forbidden, type, type:float) forbidden=1 must reject defined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 21 - (tags=clause:forbidden, type, type:float) forbidden=1 must reject defined value
# {
# 'input' => undef,
# 'name' => 'default: must accept valid default 1.1',
# 'schema' => [
# 'float*',
# 'default',
# '1.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:default'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default, type, type:float) default: must accept valid default 1.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 22 - (tags=clause:default, type, type:float) default: must accept valid default 1.1
# {
# 'input' => undef,
# 'name' => 'default: must reject invalid default []',
# 'schema' => [
# 'float*',
# 'default',
# []
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:default'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:default, type, type:float) default: must reject invalid default []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 23 - (tags=clause:default, type, type:float) default: must reject invalid default []
# {
# 'dies' => 1,
# 'input' => '1.1',
# 'name' => 'clause (dies, unknown clause)',
# 'schema' => [
# 'float*',
# 'clause',
# [
# 'foo',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:clause'
# ]
# }
# Subtest: (tags=clause:clause, type, type:float) clause (dies, unknown clause)
ok 1 - compile error
1..1
ok 24 - (tags=clause:clause, type, type:float) clause (dies, unknown clause)
# {
# 'input' => '1.1',
# 'name' => 'clause (ok)',
# 'schema' => [
# 'float*',
# 'clause',
# [
# 'min',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:clause'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clause, type, type:float) clause (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 25 - (tags=clause:clause, type, type:float) clause (ok)
# {
# 'input' => '1.1',
# 'name' => 'clause (ok) + clause nok = nok',
# 'schema' => [
# 'float*',
# 'clause',
# [
# 'min',
# 1
# ],
# 'max',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:float) clause (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 26 - (tags=clause:clause, type, type:float) clause (ok) + clause nok = nok
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'clause (nok)',
# 'schema' => [
# 'float*',
# 'clause',
# [
# 'min',
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:float) clause (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 27 - (tags=clause:clause, type, type:float) clause (nok)
# {
# 'dies' => 1,
# 'input' => '1.1',
# 'name' => 'clset (dies, unknown clause)',
# 'schema' => [
# 'float*',
# 'clset',
# {
# 'foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:float) clset (dies, unknown clause)
ok 1 - compile error
1..1
ok 28 - (tags=clause:clset, type, type:float) clset (dies, unknown clause)
# {
# 'dies' => 1,
# 'input' => '1.1',
# 'name' => 'clset (dies, unknown attr)',
# 'schema' => [
# 'float*',
# 'clset',
# {
# 'min_len' => 1,
# 'min_len.foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:float) clset (dies, unknown attr)
ok 1 - compile error
1..1
ok 29 - (tags=clause:clset, type, type:float) clset (dies, unknown attr)
# {
# 'input' => '1.1',
# 'name' => 'clset (empty = ok)',
# 'schema' => [
# 'float*',
# 'clset',
# {}
# ],
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:float) clset (empty = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 30 - (tags=type, type:float) clset (empty = ok)
# {
# 'input' => '1.1',
# 'name' => 'clset (ignored clause/attr = ok)',
# 'schema' => [
# 'float*',
# 'clset',
# {
# '_foo' => 1,
# 'foo._bar' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:float) clset (ignored clause/attr = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 31 - (tags=clause:clset, type, type:float) clset (ignored clause/attr = ok)
# {
# 'input' => '1.1',
# 'name' => 'clset (ok + ok = ok)',
# 'schema' => [
# 'float*',
# 'clset',
# {
# 'max' => '1.1',
# 'min' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:float) clset (ok + ok = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 32 - (tags=clause:clset, type, type:float) clset (ok + ok = ok)
# {
# 'input' => '1.1',
# 'name' => 'clset (ok) + clause nok = nok',
# 'schema' => [
# 'float*',
# 'clset',
# {
# 'min' => 1
# },
# 'max',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:float) clset (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 33 - (tags=clause:clset, type, type:float) clset (ok) + clause nok = nok
# {
# 'input' => '1.1',
# 'name' => 'clset (ok + nok = nok)',
# 'schema' => [
# 'float*',
# 'clset',
# {
# 'max' => 1,
# 'min' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:float) clset (ok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 34 - (tags=clause:clset, type, type:float) clset (ok + nok = nok)
# {
# 'input' => '1.1',
# 'name' => 'clset (nok + ok = nok)',
# 'schema' => [
# 'float*',
# 'clset',
# {
# 'max' => '1.1',
# 'min' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:float) clset (nok + ok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 35 - (tags=clause:clset, type, type:float) clset (nok + ok = nok)
# {
# 'input' => '1.1',
# 'name' => 'clset (nok + nok = nok)',
# 'schema' => [
# 'float*',
# 'clset',
# {
# 'max' => 1,
# 'min' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:float) clset (nok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 36 - (tags=clause:clset, type, type:float) clset (nok + nok = nok)
# {
# 'input' => undef,
# 'name' => 'ok',
# 'schema' => [
# 'float',
# {
# 'ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:ok'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:ok, type, type:float) ok
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 37 - (tags=clause:ok, type, type:float) ok
# {
# 'input' => undef,
# 'name' => 'ok + op not (nok)',
# 'schema' => [
# 'float',
# {
# '!ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:ok',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:ok, op, op:not, type, type:float) ok + op not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 38 - (tags=clause:ok, op, op:not, type, type:float) ok + op not (nok)
# {
# 'input' => '0.1',
# 'name' => '.err_level=error (clause=min, ok)',
# 'schema' => [
# 'float',
# 'min',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:float) .err_level=error (clause=min, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 39 - (tags=attr, attr:err_level, type, type:float) .err_level=error (clause=min, ok)
# {
# 'input' => '-0.1',
# 'name' => '.err_level=error (clause=min, nok)',
# 'schema' => [
# 'float',
# 'min',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 0
# }
# Subtest: (tags=attr, attr:err_level, type, type:float) .err_level=error (clause=min, nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 40 - (tags=attr, attr:err_level, type, type:float) .err_level=error (clause=min, nok)
# {
# 'input' => '0.1',
# 'name' => '.err_level=warn (clause=min, ok)',
# 'schema' => [
# 'float',
# 'min',
# 0,
# 'min.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:float) .err_level=warn (clause=min, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 41 - (tags=attr, attr:err_level, type, type:float) .err_level=warn (clause=min, ok)
# {
# 'input' => '-0.1',
# 'name' => '.err_level=warn (clause=min, nok)',
# 'schema' => [
# 'float*',
# 'min',
# 0,
# 'min.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1,
# 'warnings' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:float) .err_level=warn (clause=min, nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 42 - (tags=attr, attr:err_level, type, type:float) .err_level=warn (clause=min, nok)
# {
# 'input' => '1.1',
# 'name' => 'is: must accept same value',
# 'schema' => [
# 'float',
# 'is',
# '1.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, type, type:float) is: must accept same value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 43 - (tags=clause:is, type, type:float) is: must accept same value
# {
# 'input' => '1.1',
# 'name' => 'is: must reject different value',
# 'schema' => [
# 'float',
# 'is',
# '1.2'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, type, type:float) is: must reject different value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 44 - (tags=clause:is, type, type:float) is: must reject different value
# {
# 'input' => '1.1',
# 'name' => '!is (nok)',
# 'schema' => [
# 'float',
# '!is',
# '1.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:float) !is (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 45 - (tags=clause:is, op, op:not, opshortcut, type, type:float) !is (nok)
# {
# 'input' => '1.1',
# 'name' => '!is (ok)',
# 'schema' => [
# 'float',
# '!is',
# '1.2'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:float) !is (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 46 - (tags=clause:is, op, op:not, opshortcut, type, type:float) !is (ok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=not (nok)',
# 'schema' => [
# 'float',
# 'is',
# '1.1',
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, type, type:float) is.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 47 - (tags=clause:is, op, op:not, type, type:float) is.op=not (nok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=not (ok)',
# 'schema' => [
# 'float',
# 'is',
# '1.2',
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, type, type:float) is.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 48 - (tags=clause:is, op, op:not, type, type:float) is.op=not (ok)
# {
# 'input' => '1.1',
# 'name' => 'is& (no items)',
# 'schema' => [
# 'float',
# 'is&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:float) is& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 49 - (tags=clause:is, op, op:and, opshortcut, type, type:float) is& (no items)
# {
# 'input' => '1.1',
# 'name' => 'is& (ok)',
# 'schema' => [
# 'float',
# 'is&',
# [
# '1.1',
# '1.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:float) is& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 50 - (tags=clause:is, op, op:and, opshortcut, type, type:float) is& (ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is& (nok + ok)',
# 'schema' => [
# 'float',
# 'is&',
# [
# '1.2',
# '1.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:float) is& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 51 - (tags=clause:is, op, op:and, opshortcut, type, type:float) is& (nok + ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is& (ok + nok)',
# 'schema' => [
# 'float',
# 'is&',
# [
# '1.1',
# '1.2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:float) is& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 52 - (tags=clause:is, op, op:and, opshortcut, type, type:float) is& (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is& (nok + nok)',
# 'schema' => [
# 'float',
# 'is&',
# [
# '1.2',
# '1.2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:float) is& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 53 - (tags=clause:is, op, op:and, opshortcut, type, type:float) is& (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=and (no items)',
# 'schema' => [
# 'float',
# 'is',
# [],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:float) is.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 54 - (tags=type, type:float) is.op=and (no items)
# {
# 'input' => '1.1',
# 'name' => 'is.op=and (ok)',
# 'schema' => [
# 'float',
# 'is',
# [
# '1.1',
# '1.1'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, type, type:float) is.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 55 - (tags=clause:is, op, op:and, type, type:float) is.op=and (ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=and (nok + ok)',
# 'schema' => [
# 'float',
# 'is',
# [
# '1.2',
# '1.1'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:float) is.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 56 - (tags=clause:is, op, op:and, type, type:float) is.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=and (ok + nok)',
# 'schema' => [
# 'float',
# 'is',
# [
# '1.1',
# '1.2'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:float) is.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 57 - (tags=clause:is, op, op:and, type, type:float) is.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=and (nok + nok)',
# 'schema' => [
# 'float',
# 'is',
# [
# '1.2',
# '1.2'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:float) is.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 58 - (tags=clause:is, op, op:and, type, type:float) is.op=and (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'is| (no items)',
# 'schema' => [
# 'float',
# 'is|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:float) is| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 59 - (tags=clause:is, op, op:or, opshortcut, type, type:float) is| (no items)
# {
# 'input' => '1.1',
# 'name' => 'is| (ok)',
# 'schema' => [
# 'float',
# 'is|',
# [
# '1.1',
# '1.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:float) is| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 60 - (tags=clause:is, op, op:or, opshortcut, type, type:float) is| (ok)
# {
# 'input' => '1.1',
# 'name' => 'is| (nok + ok)',
# 'schema' => [
# 'float',
# 'is|',
# [
# '1.2',
# '1.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:float) is| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 61 - (tags=clause:is, op, op:or, opshortcut, type, type:float) is| (nok + ok)
# {
# 'input' => '1.1',
# 'name' => 'is| (ok + nok)',
# 'schema' => [
# 'float',
# 'is|',
# [
# '1.1',
# '1.2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:float) is| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 62 - (tags=clause:is, op, op:or, opshortcut, type, type:float) is| (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is| (nok + nok)',
# 'schema' => [
# 'float',
# 'is|',
# [
# '1.2',
# '1.2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:float) is| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 63 - (tags=clause:is, op, op:or, opshortcut, type, type:float) is| (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=or (no items)',
# 'schema' => [
# 'float',
# 'is',
# [],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:float) is.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 64 - (tags=clause:is, op, op:or, type, type:float) is.op=or (no items)
# {
# 'input' => '1.1',
# 'name' => 'is.op=or (ok)',
# 'schema' => [
# 'float',
# 'is',
# [
# '1.1',
# '1.1'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:float) is.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 65 - (tags=clause:is, op, op:or, type, type:float) is.op=or (ok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=or (nok + ok)',
# 'schema' => [
# 'float',
# 'is',
# [
# '1.2',
# '1.1'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:float) is.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 66 - (tags=clause:is, op, op:or, type, type:float) is.op=or (nok + ok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=or (ok + nok)',
# 'schema' => [
# 'float',
# 'is',
# [
# '1.1',
# '1.2'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:float) is.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 67 - (tags=clause:is, op, op:or, type, type:float) is.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=or (nok + nok)',
# 'schema' => [
# 'float',
# 'is',
# [
# '1.2',
# '1.2'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, type, type:float) is.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 68 - (tags=clause:is, op, op:or, type, type:float) is.op=or (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=none (empty items)',
# 'schema' => [
# 'float',
# 'is',
# [],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:float) is.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 69 - (tags=clause:is, op, op:none, type, type:float) is.op=none (empty items)
# {
# 'input' => '1.1',
# 'name' => 'is.op=none (nok + nok)',
# 'schema' => [
# 'float',
# 'is',
# [
# '1.2',
# '1.2'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:float) is.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 70 - (tags=clause:is, op, op:none, type, type:float) is.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=none (nok + ok)',
# 'schema' => [
# 'float',
# 'is',
# [
# '1.2',
# '1.1'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:float) is.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 71 - (tags=clause:is, op, op:none, type, type:float) is.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=none (ok + nok)',
# 'schema' => [
# 'float',
# 'is',
# [
# '1.1',
# '1.2'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:float) is.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 72 - (tags=clause:is, op, op:none, type, type:float) is.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=none (ok + ok)',
# 'schema' => [
# 'float',
# 'is',
# [
# '1.1',
# '1.1'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:float) is.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 73 - (tags=clause:is, op, op:none, type, type:float) is.op=none (ok + ok)
# {
# 'input' => '1.1',
# 'name' => 'in: must accept valid choices',
# 'schema' => [
# 'float',
# 'in',
# [
# '1.1',
# '1.2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, type, type:float) in: must accept valid choices
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 74 - (tags=clause:in, type, type:float) in: must accept valid choices
# {
# 'input' => '1.1',
# 'name' => 'in: must reject empty choices',
# 'schema' => [
# 'float',
# 'in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, type, type:float) in: must reject empty choices
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 75 - (tags=clause:in, type, type:float) in: must reject empty choices
# {
# 'input' => '1.1',
# 'name' => '!in (nok)',
# 'schema' => [
# 'float',
# '!in',
# [
# '1.1',
# '1.2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:float) !in (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 76 - (tags=clause:in, op, op:not, opshortcut, type, type:float) !in (nok)
# {
# 'input' => '1.1',
# 'name' => '!in (ok)',
# 'schema' => [
# 'float',
# '!in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:float) !in (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 77 - (tags=clause:in, op, op:not, opshortcut, type, type:float) !in (ok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=not (nok)',
# 'schema' => [
# 'float',
# 'in',
# [
# '1.1',
# '1.2'
# ],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, type, type:float) in.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 78 - (tags=clause:in, op, op:not, type, type:float) in.op=not (nok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=not (ok)',
# 'schema' => [
# 'float',
# 'in',
# [],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, type, type:float) in.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 79 - (tags=clause:in, op, op:not, type, type:float) in.op=not (ok)
# {
# 'input' => '1.1',
# 'name' => 'in& (no items)',
# 'schema' => [
# 'float',
# 'in&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:float) in& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 80 - (tags=clause:in, op, op:and, opshortcut, type, type:float) in& (no items)
# {
# 'input' => '1.1',
# 'name' => 'in& (ok)',
# 'schema' => [
# 'float',
# 'in&',
# [
# [
# '1.1',
# '1.2'
# ],
# [
# '1.1',
# '1.2'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:float) in& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 81 - (tags=clause:in, op, op:and, opshortcut, type, type:float) in& (ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in& (nok + ok)',
# 'schema' => [
# 'float',
# 'in&',
# [
# [],
# [
# '1.1',
# '1.2'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:float) in& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 82 - (tags=clause:in, op, op:and, opshortcut, type, type:float) in& (nok + ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in& (ok + nok)',
# 'schema' => [
# 'float',
# 'in&',
# [
# [
# '1.1',
# '1.2'
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:float) in& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 83 - (tags=clause:in, op, op:and, opshortcut, type, type:float) in& (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in& (nok + nok)',
# 'schema' => [
# 'float',
# 'in&',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:float) in& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 84 - (tags=clause:in, op, op:and, opshortcut, type, type:float) in& (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=and (no items)',
# 'schema' => [
# 'float',
# 'in',
# [],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:float) in.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 85 - (tags=type, type:float) in.op=and (no items)
# {
# 'input' => '1.1',
# 'name' => 'in.op=and (ok)',
# 'schema' => [
# 'float',
# 'in',
# [
# [
# '1.1',
# '1.2'
# ],
# [
# '1.1',
# '1.2'
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, type, type:float) in.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 86 - (tags=clause:in, op, op:and, type, type:float) in.op=and (ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=and (nok + ok)',
# 'schema' => [
# 'float',
# 'in',
# [
# [],
# [
# '1.1',
# '1.2'
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:float) in.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 87 - (tags=clause:in, op, op:and, type, type:float) in.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=and (ok + nok)',
# 'schema' => [
# 'float',
# 'in',
# [
# [
# '1.1',
# '1.2'
# ],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:float) in.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 88 - (tags=clause:in, op, op:and, type, type:float) in.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=and (nok + nok)',
# 'schema' => [
# 'float',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:float) in.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 89 - (tags=clause:in, op, op:and, type, type:float) in.op=and (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'in| (no items)',
# 'schema' => [
# 'float',
# 'in|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:float) in| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 90 - (tags=clause:in, op, op:or, opshortcut, type, type:float) in| (no items)
# {
# 'input' => '1.1',
# 'name' => 'in| (ok)',
# 'schema' => [
# 'float',
# 'in|',
# [
# [
# '1.1',
# '1.2'
# ],
# [
# '1.1',
# '1.2'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:float) in| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 91 - (tags=clause:in, op, op:or, opshortcut, type, type:float) in| (ok)
# {
# 'input' => '1.1',
# 'name' => 'in| (nok + ok)',
# 'schema' => [
# 'float',
# 'in|',
# [
# [],
# [
# '1.1',
# '1.2'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:float) in| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 92 - (tags=clause:in, op, op:or, opshortcut, type, type:float) in| (nok + ok)
# {
# 'input' => '1.1',
# 'name' => 'in| (ok + nok)',
# 'schema' => [
# 'float',
# 'in|',
# [
# [
# '1.1',
# '1.2'
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:float) in| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 93 - (tags=clause:in, op, op:or, opshortcut, type, type:float) in| (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in| (nok + nok)',
# 'schema' => [
# 'float',
# 'in|',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:float) in| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 94 - (tags=clause:in, op, op:or, opshortcut, type, type:float) in| (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=or (no items)',
# 'schema' => [
# 'float',
# 'in',
# [],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:float) in.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 95 - (tags=clause:in, op, op:or, type, type:float) in.op=or (no items)
# {
# 'input' => '1.1',
# 'name' => 'in.op=or (ok)',
# 'schema' => [
# 'float',
# 'in',
# [
# [
# '1.1',
# '1.2'
# ],
# [
# '1.1',
# '1.2'
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:float) in.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 96 - (tags=clause:in, op, op:or, type, type:float) in.op=or (ok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=or (nok + ok)',
# 'schema' => [
# 'float',
# 'in',
# [
# [],
# [
# '1.1',
# '1.2'
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:float) in.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 97 - (tags=clause:in, op, op:or, type, type:float) in.op=or (nok + ok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=or (ok + nok)',
# 'schema' => [
# 'float',
# 'in',
# [
# [
# '1.1',
# '1.2'
# ],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:float) in.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 98 - (tags=clause:in, op, op:or, type, type:float) in.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=or (nok + nok)',
# 'schema' => [
# 'float',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, type, type:float) in.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 99 - (tags=clause:in, op, op:or, type, type:float) in.op=or (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=none (empty items)',
# 'schema' => [
# 'float',
# 'in',
# [],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:float) in.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 100 - (tags=clause:in, op, op:none, type, type:float) in.op=none (empty items)
# {
# 'input' => '1.1',
# 'name' => 'in.op=none (nok + nok)',
# 'schema' => [
# 'float',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:float) in.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 101 - (tags=clause:in, op, op:none, type, type:float) in.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=none (nok + ok)',
# 'schema' => [
# 'float',
# 'in',
# [
# [],
# [
# '1.1',
# '1.2'
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:float) in.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 102 - (tags=clause:in, op, op:none, type, type:float) in.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=none (ok + nok)',
# 'schema' => [
# 'float',
# 'in',
# [
# [
# '1.1',
# '1.2'
# ],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:float) in.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 103 - (tags=clause:in, op, op:none, type, type:float) in.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=none (ok + ok)',
# 'schema' => [
# 'float',
# 'in',
# [
# [
# '1.1',
# '1.2'
# ],
# [
# '1.1',
# '1.2'
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:float) in.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 104 - (tags=clause:in, op, op:none, type, type:float) in.op=none (ok + ok)
# {
# 'input' => '2.1',
# 'name' => 'min: 2.1 -3.1',
# 'schema' => [
# 'float',
# 'min',
# '-3.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:float) min: 2.1 -3.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 105 - (tags=clause:min, type, type:float) min: 2.1 -3.1
# {
# 'input' => '2.1',
# 'name' => 'min: 2.1 2.1',
# 'schema' => [
# 'float',
# 'min',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:float) min: 2.1 2.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 106 - (tags=clause:min, type, type:float) min: 2.1 2.1
# {
# 'input' => '-3.1',
# 'name' => 'min: -3.1 2.1 -> fail',
# 'schema' => [
# 'float',
# 'min',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:min'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:min, type, type:float) min: -3.1 2.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 107 - (tags=clause:min, type, type:float) min: -3.1 2.1 -> fail
# {
# 'input' => '2.1',
# 'name' => 'xmin: 2.1 -3.1',
# 'schema' => [
# 'float',
# 'xmin',
# '-3.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:xmin'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmin, type, type:float) xmin: 2.1 -3.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 108 - (tags=clause:xmin, type, type:float) xmin: 2.1 -3.1
# {
# 'input' => '2.1',
# 'name' => 'xmin: 2.1 2.1 -> fail',
# 'schema' => [
# 'float',
# 'xmin',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:float) xmin: 2.1 2.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 109 - (tags=clause:xmin, type, type:float) xmin: 2.1 2.1 -> fail
# {
# 'input' => '-3.1',
# 'name' => 'xmin: -3.1 2.1 -> fail',
# 'schema' => [
# 'float',
# 'xmin',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:float) xmin: -3.1 2.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 110 - (tags=clause:xmin, type, type:float) xmin: -3.1 2.1 -> fail
# {
# 'input' => '2.1',
# 'name' => 'max: 2.1 -3.1 -> fail',
# 'schema' => [
# 'float',
# 'max',
# '-3.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:max'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:max, type, type:float) max: 2.1 -3.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 111 - (tags=clause:max, type, type:float) max: 2.1 -3.1 -> fail
# {
# 'input' => '2.1',
# 'name' => 'max: 2.1 2.1',
# 'schema' => [
# 'float',
# 'max',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:float) max: 2.1 2.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 112 - (tags=clause:max, type, type:float) max: 2.1 2.1
# {
# 'input' => '-3.1',
# 'name' => 'max: -3.1 2.1',
# 'schema' => [
# 'float',
# 'max',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:float) max: -3.1 2.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 113 - (tags=clause:max, type, type:float) max: -3.1 2.1
# {
# 'input' => '2.1',
# 'name' => 'xmax: 2.1 -3.1 -> fail',
# 'schema' => [
# 'float',
# 'xmax',
# '-3.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:float) xmax: 2.1 -3.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 114 - (tags=clause:xmax, type, type:float) xmax: 2.1 -3.1 -> fail
# {
# 'input' => '2.1',
# 'name' => 'xmax: 2.1 2.1 -> fail',
# 'schema' => [
# 'float',
# 'xmax',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:float) xmax: 2.1 2.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 115 - (tags=clause:xmax, type, type:float) xmax: 2.1 2.1 -> fail
# {
# 'input' => '-3.1',
# 'name' => 'xmax: -3.1 2.1',
# 'schema' => [
# 'float',
# 'xmax',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:xmax'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmax, type, type:float) xmax: -3.1 2.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 116 - (tags=clause:xmax, type, type:float) xmax: -3.1 2.1
# {
# 'input' => '2.1',
# 'name' => 'between: 2.1 -3.1 & 4.1',
# 'schema' => [
# 'float',
# 'between',
# [
# '-3.1',
# '4.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:float) between: 2.1 -3.1 & 4.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 117 - (tags=clause:between, type, type:float) between: 2.1 -3.1 & 4.1
# {
# 'input' => '2.1',
# 'name' => 'between: 2.1 -3.1 & 2.1',
# 'schema' => [
# 'float',
# 'between',
# [
# '-3.1',
# '2.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:float) between: 2.1 -3.1 & 2.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 118 - (tags=clause:between, type, type:float) between: 2.1 -3.1 & 2.1
# {
# 'input' => '2.1',
# 'name' => 'between: 2.1 2.1 & 2.1',
# 'schema' => [
# 'float',
# 'between',
# [
# '2.1',
# '2.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:float) between: 2.1 2.1 & 2.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 119 - (tags=clause:between, type, type:float) between: 2.1 2.1 & 2.1
# {
# 'input' => '-3.1',
# 'name' => 'between: -3.1 2.1 & 4.1 -> fail',
# 'schema' => [
# 'float',
# 'between',
# [
# '2.1',
# '4.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, type, type:float) between: -3.1 2.1 & 4.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 120 - (tags=clause:between, type, type:float) between: -3.1 2.1 & 4.1 -> fail
# {
# 'input' => '2.1',
# 'name' => 'xbetween: 2.1 -3.1 & 4.1',
# 'schema' => [
# 'float',
# 'xbetween',
# [
# '-3.1',
# '4.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:xbetween'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xbetween, type, type:float) xbetween: 2.1 -3.1 & 4.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 121 - (tags=clause:xbetween, type, type:float) xbetween: 2.1 -3.1 & 4.1
# {
# 'input' => '2.1',
# 'name' => 'xbetween: 2.1 -3.1 & 2.1 -> fail',
# 'schema' => [
# 'float',
# 'xbetween',
# [
# '-3.1',
# '2.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:float) xbetween: 2.1 -3.1 & 2.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 122 - (tags=clause:xbetween, type, type:float) xbetween: 2.1 -3.1 & 2.1 -> fail
# {
# 'input' => '2.1',
# 'name' => 'xbetween: 2.1 2.1 & 2.1 -> fail',
# 'schema' => [
# 'float',
# 'xbetween',
# [
# '2.1',
# '2.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:float) xbetween: 2.1 2.1 & 2.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 123 - (tags=clause:xbetween, type, type:float) xbetween: 2.1 2.1 & 2.1 -> fail
# {
# 'input' => '-3.1',
# 'name' => 'xbetween: -3.1 2.1 & 4.1 -> fail',
# 'schema' => [
# 'float',
# 'xbetween',
# [
# '2.1',
# '4.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:float) xbetween: -3.1 2.1 & 4.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 124 - (tags=clause:xbetween, type, type:float) xbetween: -3.1 2.1 & 4.1 -> fail
# {
# 'input' => '-3.1',
# 'name' => '!between (nok)',
# 'schema' => [
# 'float',
# '!between',
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:not, opshortcut, type, type:float) !between (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 125 - (tags=clause:between, op, op:not, opshortcut, type, type:float) !between (nok)
# {
# 'input' => '-3.1',
# 'name' => '!between (ok)',
# 'schema' => [
# 'float',
# '!between',
# [
# '2.1',
# '2.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:not, opshortcut, type, type:float) !between (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 126 - (tags=clause:between, op, op:not, opshortcut, type, type:float) !between (ok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=not (nok)',
# 'schema' => [
# 'float',
# 'between',
# [
# '-3.1',
# '-3.1'
# ],
# 'between.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:not, type, type:float) between.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 127 - (tags=clause:between, op, op:not, type, type:float) between.op=not (nok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=not (ok)',
# 'schema' => [
# 'float',
# 'between',
# [
# '2.1',
# '2.1'
# ],
# 'between.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:not, type, type:float) between.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 128 - (tags=clause:between, op, op:not, type, type:float) between.op=not (ok)
# {
# 'input' => '-3.1',
# 'name' => 'between& (no items)',
# 'schema' => [
# 'float',
# 'between&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:float) between& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 129 - (tags=clause:between, op, op:and, opshortcut, type, type:float) between& (no items)
# {
# 'input' => '-3.1',
# 'name' => 'between& (ok)',
# 'schema' => [
# 'float',
# 'between&',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:float) between& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 130 - (tags=clause:between, op, op:and, opshortcut, type, type:float) between& (ok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between& (nok + ok)',
# 'schema' => [
# 'float',
# 'between&',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:float) between& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 131 - (tags=clause:between, op, op:and, opshortcut, type, type:float) between& (nok + ok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between& (ok + nok)',
# 'schema' => [
# 'float',
# 'between&',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:float) between& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 132 - (tags=clause:between, op, op:and, opshortcut, type, type:float) between& (ok + nok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between& (nok + nok)',
# 'schema' => [
# 'float',
# 'between&',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:float) between& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 133 - (tags=clause:between, op, op:and, opshortcut, type, type:float) between& (nok + nok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=and (no items)',
# 'schema' => [
# 'float',
# 'between',
# [],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:float) between.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 134 - (tags=type, type:float) between.op=and (no items)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=and (ok)',
# 'schema' => [
# 'float',
# 'between',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, type, type:float) between.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 135 - (tags=clause:between, op, op:and, type, type:float) between.op=and (ok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=and (nok + ok)',
# 'schema' => [
# 'float',
# 'between',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:float) between.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 136 - (tags=clause:between, op, op:and, type, type:float) between.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=and (ok + nok)',
# 'schema' => [
# 'float',
# 'between',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:float) between.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 137 - (tags=clause:between, op, op:and, type, type:float) between.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=and (nok + nok)',
# 'schema' => [
# 'float',
# 'between',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:float) between.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 138 - (tags=clause:between, op, op:and, type, type:float) between.op=and (nok + nok)
# {
# 'input' => '-3.1',
# 'name' => 'between| (no items)',
# 'schema' => [
# 'float',
# 'between|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:float) between| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 139 - (tags=clause:between, op, op:or, opshortcut, type, type:float) between| (no items)
# {
# 'input' => '-3.1',
# 'name' => 'between| (ok)',
# 'schema' => [
# 'float',
# 'between|',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:float) between| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 140 - (tags=clause:between, op, op:or, opshortcut, type, type:float) between| (ok)
# {
# 'input' => '-3.1',
# 'name' => 'between| (nok + ok)',
# 'schema' => [
# 'float',
# 'between|',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:float) between| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 141 - (tags=clause:between, op, op:or, opshortcut, type, type:float) between| (nok + ok)
# {
# 'input' => '-3.1',
# 'name' => 'between| (ok + nok)',
# 'schema' => [
# 'float',
# 'between|',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:float) between| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 142 - (tags=clause:between, op, op:or, opshortcut, type, type:float) between| (ok + nok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between| (nok + nok)',
# 'schema' => [
# 'float',
# 'between|',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:float) between| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 143 - (tags=clause:between, op, op:or, opshortcut, type, type:float) between| (nok + nok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=or (no items)',
# 'schema' => [
# 'float',
# 'between',
# [],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:float) between.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 144 - (tags=clause:between, op, op:or, type, type:float) between.op=or (no items)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=or (ok)',
# 'schema' => [
# 'float',
# 'between',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:float) between.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 145 - (tags=clause:between, op, op:or, type, type:float) between.op=or (ok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=or (nok + ok)',
# 'schema' => [
# 'float',
# 'between',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:float) between.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 146 - (tags=clause:between, op, op:or, type, type:float) between.op=or (nok + ok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=or (ok + nok)',
# 'schema' => [
# 'float',
# 'between',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:float) between.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 147 - (tags=clause:between, op, op:or, type, type:float) between.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=or (nok + nok)',
# 'schema' => [
# 'float',
# 'between',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:or, type, type:float) between.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 148 - (tags=clause:between, op, op:or, type, type:float) between.op=or (nok + nok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=none (empty items)',
# 'schema' => [
# 'float',
# 'between',
# [],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:none, type, type:float) between.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 149 - (tags=clause:between, op, op:none, type, type:float) between.op=none (empty items)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=none (nok + nok)',
# 'schema' => [
# 'float',
# 'between',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:none, type, type:float) between.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 150 - (tags=clause:between, op, op:none, type, type:float) between.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=none (nok + ok)',
# 'schema' => [
# 'float',
# 'between',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:float) between.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 151 - (tags=clause:between, op, op:none, type, type:float) between.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=none (ok + nok)',
# 'schema' => [
# 'float',
# 'between',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:float) between.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 152 - (tags=clause:between, op, op:none, type, type:float) between.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=none (ok + ok)',
# 'schema' => [
# 'float',
# 'between',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:float',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:float) between.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 153 - (tags=clause:between, op, op:none, type, type:float) between.op=none (ok + ok)
ok 154
1..154
ok 9 - 10-type-float.json
# Subtest: 10-type-hash.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => {},
# 'name' => 'type check: must accept {}',
# 'schema' => 'hash',
# 'tags' => [
# 'type',
# 'type:hash'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:hash) type check: must accept {}
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=type, type:hash) type check: must accept {}
# {
# 'input' => {
# 'a' => '1'
# },
# 'name' => 'type check: must accept { a => 1 }',
# 'schema' => 'hash',
# 'tags' => [
# 'type',
# 'type:hash'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:hash) type check: must accept { a => 1 }
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=type, type:hash) type check: must accept { a => 1 }
# {
# 'input' => {
# '' => []
# },
# 'name' => 'type check: must accept { "" => [] }',
# 'schema' => 'hash',
# 'tags' => [
# 'type',
# 'type:hash'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:hash) type check: must accept { "" => [] }
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 3 - (tags=type, type:hash) type check: must accept { "" => [] }
# {
# 'input' => 1,
# 'name' => 'type check: must reject 1',
# 'schema' => 'hash',
# 'tags' => [
# 'type',
# 'type:hash'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:hash) type check: must reject 1
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 4 - (tags=type, type:hash) type check: must reject 1
# {
# 'input' => 'a',
# 'name' => 'type check: must reject a',
# 'schema' => 'hash',
# 'tags' => [
# 'type',
# 'type:hash'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:hash) type check: must reject a
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 5 - (tags=type, type:hash) type check: must reject a
# {
# 'input' => [],
# 'name' => 'type check: must reject []',
# 'schema' => 'hash',
# 'tags' => [
# 'type',
# 'type:hash'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:hash) type check: must reject []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 6 - (tags=type, type:hash) type check: must reject []
# {
# 'input' => undef,
# 'name' => 'must accept undefined value',
# 'schema' => 'hash',
# 'tags' => [
# 'type',
# 'type:hash'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:hash) must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 7 - (tags=type, type:hash) must accept undefined value
# {
# 'input' => undef,
# 'name' => 'defhash_v',
# 'schema' => [
# 'hash',
# 'defhash_v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:defhash_v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:defhash_v, type, type:hash) defhash_v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 8 - (tags=clause:defhash_v, type, type:hash) defhash_v
# {
# 'input' => undef,
# 'name' => 'v',
# 'schema' => [
# 'hash',
# 'v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:v, type, type:hash) v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 9 - (tags=clause:v, type, type:hash) v
# {
# 'input' => undef,
# 'name' => 'c',
# 'schema' => [
# 'hash',
# 'c.foo.bar',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:c'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:c, type, type:hash) c
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 10 - (tags=clause:c, type, type:hash) c
# {
# 'input' => undef,
# 'name' => 'default_lang',
# 'schema' => [
# 'hash',
# 'default_lang',
# 'id_ID'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:default_lang'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default_lang, type, type:hash) default_lang
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 11 - (tags=clause:default_lang, type, type:hash) default_lang
# {
# 'input' => undef,
# 'name' => 'name',
# 'schema' => [
# 'hash',
# 'name',
# 'some name'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:name'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:name, type, type:hash) name
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 12 - (tags=clause:name, type, type:hash) name
# {
# 'input' => undef,
# 'name' => 'summary',
# 'schema' => [
# 'hash',
# 'summary',
# 'some summary'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:summary'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:summary, type, type:hash) summary
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 13 - (tags=clause:summary, type, type:hash) summary
# {
# 'input' => undef,
# 'name' => 'description',
# 'schema' => [
# 'hash',
# 'description',
# 'some description and `markdown`'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:description'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:description, type, type:hash) description
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 14 - (tags=clause:description, type, type:hash) description
# {
# 'input' => undef,
# 'name' => 'tags',
# 'schema' => [
# 'hash',
# 'tags',
# [
# 'some',
# 'tags'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:tags'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:tags, type, type:hash) tags
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 15 - (tags=clause:tags, type, type:hash) tags
# {
# 'input' => undef,
# 'name' => 'req=0 must accept undefined value',
# 'schema' => [
# 'hash',
# 'req',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:req'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req, type, type:hash) req=0 must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 16 - (tags=clause:req, type, type:hash) req=0 must accept undefined value
# {
# 'input' => undef,
# 'name' => 'req=1 must reject undefined value',
# 'schema' => [
# 'hash',
# 'req',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:req'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:req, type, type:hash) req=1 must reject undefined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 17 - (tags=clause:req, type, type:hash) req=1 must reject undefined value
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'forbidden=0 must accept defined value',
# 'schema' => [
# 'hash',
# 'forbidden',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:forbidden'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden, type, type:hash) forbidden=0 must accept defined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 18 - (tags=clause:forbidden, type, type:hash) forbidden=0 must accept defined value
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'forbidden=1 must reject defined value',
# 'schema' => [
# 'hash',
# 'forbidden',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:forbidden'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:forbidden, type, type:hash) forbidden=1 must reject defined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 19 - (tags=clause:forbidden, type, type:hash) forbidden=1 must reject defined value
# {
# 'input' => undef,
# 'name' => 'default: must accept valid default {}',
# 'schema' => [
# 'hash*',
# 'default',
# {}
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:default'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default, type, type:hash) default: must accept valid default {}
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 20 - (tags=clause:default, type, type:hash) default: must accept valid default {}
# {
# 'input' => undef,
# 'name' => 'default: must reject invalid default a',
# 'schema' => [
# 'hash*',
# 'default',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:default'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:default, type, type:hash) default: must reject invalid default a
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 21 - (tags=clause:default, type, type:hash) default: must reject invalid default a
# {
# 'dies' => 1,
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clause (dies, unknown clause)',
# 'schema' => [
# 'hash*',
# 'clause',
# [
# 'foo',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:clause'
# ]
# }
# Subtest: (tags=clause:clause, type, type:hash) clause (dies, unknown clause)
ok 1 - compile error
1..1
ok 22 - (tags=clause:clause, type, type:hash) clause (dies, unknown clause)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clause (ok)',
# 'schema' => [
# 'hash*',
# 'clause',
# [
# 'min_len',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:clause'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clause, type, type:hash) clause (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 23 - (tags=clause:clause, type, type:hash) clause (ok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clause (ok) + clause nok = nok',
# 'schema' => [
# 'hash*',
# 'clause',
# [
# 'min_len',
# 1
# ],
# 'max_len',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:hash) clause (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 24 - (tags=clause:clause, type, type:hash) clause (ok) + clause nok = nok
# {
# 'errors' => 1,
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clause (nok)',
# 'schema' => [
# 'hash*',
# 'clause',
# [
# 'min_len',
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:hash) clause (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 25 - (tags=clause:clause, type, type:hash) clause (nok)
# {
# 'dies' => 1,
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clset (dies, unknown clause)',
# 'schema' => [
# 'hash*',
# 'clset',
# {
# 'foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:hash) clset (dies, unknown clause)
ok 1 - compile error
1..1
ok 26 - (tags=clause:clset, type, type:hash) clset (dies, unknown clause)
# {
# 'dies' => 1,
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clset (dies, unknown attr)',
# 'schema' => [
# 'hash*',
# 'clset',
# {
# 'min_len' => 1,
# 'min_len.foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:hash) clset (dies, unknown attr)
ok 1 - compile error
1..1
ok 27 - (tags=clause:clset, type, type:hash) clset (dies, unknown attr)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clset (empty = ok)',
# 'schema' => [
# 'hash*',
# 'clset',
# {}
# ],
# 'tags' => [
# 'type',
# 'type:hash'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:hash) clset (empty = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 28 - (tags=type, type:hash) clset (empty = ok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clset (ignored clause/attr = ok)',
# 'schema' => [
# 'hash*',
# 'clset',
# {
# '_foo' => 1,
# 'foo._bar' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:hash) clset (ignored clause/attr = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 29 - (tags=clause:clset, type, type:hash) clset (ignored clause/attr = ok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clset (ok + ok = ok)',
# 'schema' => [
# 'hash*',
# 'clset',
# {
# 'max_len' => 1,
# 'min_len' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:hash) clset (ok + ok = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 30 - (tags=clause:clset, type, type:hash) clset (ok + ok = ok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clset (ok) + clause nok = nok',
# 'schema' => [
# 'hash*',
# 'clset',
# {
# 'min_len' => 1
# },
# 'max_len',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:hash) clset (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 31 - (tags=clause:clset, type, type:hash) clset (ok) + clause nok = nok
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clset (ok + nok = nok)',
# 'schema' => [
# 'hash*',
# 'clset',
# {
# 'max_len' => 0,
# 'min_len' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:hash) clset (ok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 32 - (tags=clause:clset, type, type:hash) clset (ok + nok = nok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clset (nok + ok = nok)',
# 'schema' => [
# 'hash*',
# 'clset',
# {
# 'max_len' => 1,
# 'min_len' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:hash) clset (nok + ok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 33 - (tags=clause:clset, type, type:hash) clset (nok + ok = nok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'clset (nok + nok = nok)',
# 'schema' => [
# 'hash*',
# 'clset',
# {
# 'max_len' => 0,
# 'min_len' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:hash) clset (nok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 34 - (tags=clause:clset, type, type:hash) clset (nok + nok = nok)
# {
# 'input' => undef,
# 'name' => 'ok',
# 'schema' => [
# 'hash',
# {
# 'ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:ok'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:ok, type, type:hash) ok
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 35 - (tags=clause:ok, type, type:hash) ok
# {
# 'input' => undef,
# 'name' => 'ok + op not (nok)',
# 'schema' => [
# 'hash',
# {
# '!ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:ok',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:ok, op, op:not, type, type:hash) ok + op not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 36 - (tags=clause:ok, op, op:not, type, type:hash) ok + op not (nok)
# {
# 'input' => {
# 'a' => 0
# },
# 'name' => '.err_level=error (clause=is, ok)',
# 'schema' => [
# 'hash',
# 'is',
# {
# 'a' => 0
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:hash) .err_level=error (clause=is, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 37 - (tags=attr, attr:err_level, type, type:hash) .err_level=error (clause=is, ok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => '.err_level=error (clause=is, nok)',
# 'schema' => [
# 'hash',
# 'is',
# {
# 'a' => 0
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 0
# }
# Subtest: (tags=attr, attr:err_level, type, type:hash) .err_level=error (clause=is, nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 38 - (tags=attr, attr:err_level, type, type:hash) .err_level=error (clause=is, nok)
# {
# 'input' => {
# 'a' => 0
# },
# 'name' => '.err_level=warn (clause=is, ok)',
# 'schema' => [
# 'hash',
# 'is',
# {
# 'a' => 0
# },
# 'is.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:hash) .err_level=warn (clause=is, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 39 - (tags=attr, attr:err_level, type, type:hash) .err_level=warn (clause=is, ok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => '.err_level=warn (clause=is, nok)',
# 'schema' => [
# 'hash*',
# 'is',
# {
# 'a' => 0
# },
# 'is.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1,
# 'warnings' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:hash) .err_level=warn (clause=is, nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 40 - (tags=attr, attr:err_level, type, type:hash) .err_level=warn (clause=is, nok)
# {
# 'input' => {},
# 'name' => 'is: must accept same value',
# 'schema' => [
# 'hash',
# 'is',
# {}
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, type, type:hash) is: must accept same value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 41 - (tags=clause:is, type, type:hash) is: must accept same value
# {
# 'input' => {},
# 'name' => 'is: must reject different value',
# 'schema' => [
# 'hash',
# 'is',
# {
# 'a' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, type, type:hash) is: must reject different value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 42 - (tags=clause:is, type, type:hash) is: must reject different value
# {
# 'input' => {},
# 'name' => '!is (nok)',
# 'schema' => [
# 'hash',
# '!is',
# {}
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:hash) !is (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 43 - (tags=clause:is, op, op:not, opshortcut, type, type:hash) !is (nok)
# {
# 'input' => {},
# 'name' => '!is (ok)',
# 'schema' => [
# 'hash',
# '!is',
# {
# 'a' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:hash) !is (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 44 - (tags=clause:is, op, op:not, opshortcut, type, type:hash) !is (ok)
# {
# 'input' => {},
# 'name' => 'is.op=not (nok)',
# 'schema' => [
# 'hash',
# 'is',
# {},
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, type, type:hash) is.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 45 - (tags=clause:is, op, op:not, type, type:hash) is.op=not (nok)
# {
# 'input' => {},
# 'name' => 'is.op=not (ok)',
# 'schema' => [
# 'hash',
# 'is',
# {
# 'a' => 1
# },
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, type, type:hash) is.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 46 - (tags=clause:is, op, op:not, type, type:hash) is.op=not (ok)
# {
# 'input' => {},
# 'name' => 'is& (no items)',
# 'schema' => [
# 'hash',
# 'is&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:hash) is& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 47 - (tags=clause:is, op, op:and, opshortcut, type, type:hash) is& (no items)
# {
# 'input' => {},
# 'name' => 'is& (ok)',
# 'schema' => [
# 'hash',
# 'is&',
# [
# {},
# {}
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:hash) is& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 48 - (tags=clause:is, op, op:and, opshortcut, type, type:hash) is& (ok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'is& (nok + ok)',
# 'schema' => [
# 'hash',
# 'is&',
# [
# {
# 'a' => 1
# },
# {}
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:hash) is& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 49 - (tags=clause:is, op, op:and, opshortcut, type, type:hash) is& (nok + ok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'is& (ok + nok)',
# 'schema' => [
# 'hash',
# 'is&',
# [
# {},
# {
# 'a' => 1
# }
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:hash) is& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 50 - (tags=clause:is, op, op:and, opshortcut, type, type:hash) is& (ok + nok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'is& (nok + nok)',
# 'schema' => [
# 'hash',
# 'is&',
# [
# {
# 'a' => 1
# },
# {
# 'a' => 1
# }
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:hash) is& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 51 - (tags=clause:is, op, op:and, opshortcut, type, type:hash) is& (nok + nok)
# {
# 'input' => {},
# 'name' => 'is.op=and (no items)',
# 'schema' => [
# 'hash',
# 'is',
# [],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:hash'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:hash) is.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 52 - (tags=type, type:hash) is.op=and (no items)
# {
# 'input' => {},
# 'name' => 'is.op=and (ok)',
# 'schema' => [
# 'hash',
# 'is',
# [
# {},
# {}
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, type, type:hash) is.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 53 - (tags=clause:is, op, op:and, type, type:hash) is.op=and (ok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'is.op=and (nok + ok)',
# 'schema' => [
# 'hash',
# 'is',
# [
# {
# 'a' => 1
# },
# {}
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:hash) is.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 54 - (tags=clause:is, op, op:and, type, type:hash) is.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'is.op=and (ok + nok)',
# 'schema' => [
# 'hash',
# 'is',
# [
# {},
# {
# 'a' => 1
# }
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:hash) is.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 55 - (tags=clause:is, op, op:and, type, type:hash) is.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'is.op=and (nok + nok)',
# 'schema' => [
# 'hash',
# 'is',
# [
# {
# 'a' => 1
# },
# {
# 'a' => 1
# }
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:hash) is.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 56 - (tags=clause:is, op, op:and, type, type:hash) is.op=and (nok + nok)
# {
# 'input' => {},
# 'name' => 'is| (no items)',
# 'schema' => [
# 'hash',
# 'is|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:hash) is| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 57 - (tags=clause:is, op, op:or, opshortcut, type, type:hash) is| (no items)
# {
# 'input' => {},
# 'name' => 'is| (ok)',
# 'schema' => [
# 'hash',
# 'is|',
# [
# {},
# {}
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:hash) is| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 58 - (tags=clause:is, op, op:or, opshortcut, type, type:hash) is| (ok)
# {
# 'input' => {},
# 'name' => 'is| (nok + ok)',
# 'schema' => [
# 'hash',
# 'is|',
# [
# {
# 'a' => 1
# },
# {}
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:hash) is| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 59 - (tags=clause:is, op, op:or, opshortcut, type, type:hash) is| (nok + ok)
# {
# 'input' => {},
# 'name' => 'is| (ok + nok)',
# 'schema' => [
# 'hash',
# 'is|',
# [
# {},
# {
# 'a' => 1
# }
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:hash) is| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 60 - (tags=clause:is, op, op:or, opshortcut, type, type:hash) is| (ok + nok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'is| (nok + nok)',
# 'schema' => [
# 'hash',
# 'is|',
# [
# {
# 'a' => 1
# },
# {
# 'a' => 1
# }
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:hash) is| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 61 - (tags=clause:is, op, op:or, opshortcut, type, type:hash) is| (nok + nok)
# {
# 'input' => {},
# 'name' => 'is.op=or (no items)',
# 'schema' => [
# 'hash',
# 'is',
# [],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:hash) is.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 62 - (tags=clause:is, op, op:or, type, type:hash) is.op=or (no items)
# {
# 'input' => {},
# 'name' => 'is.op=or (ok)',
# 'schema' => [
# 'hash',
# 'is',
# [
# {},
# {}
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:hash) is.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 63 - (tags=clause:is, op, op:or, type, type:hash) is.op=or (ok)
# {
# 'input' => {},
# 'name' => 'is.op=or (nok + ok)',
# 'schema' => [
# 'hash',
# 'is',
# [
# {
# 'a' => 1
# },
# {}
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:hash) is.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 64 - (tags=clause:is, op, op:or, type, type:hash) is.op=or (nok + ok)
# {
# 'input' => {},
# 'name' => 'is.op=or (ok + nok)',
# 'schema' => [
# 'hash',
# 'is',
# [
# {},
# {
# 'a' => 1
# }
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:hash) is.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 65 - (tags=clause:is, op, op:or, type, type:hash) is.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'is.op=or (nok + nok)',
# 'schema' => [
# 'hash',
# 'is',
# [
# {
# 'a' => 1
# },
# {
# 'a' => 1
# }
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, type, type:hash) is.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 66 - (tags=clause:is, op, op:or, type, type:hash) is.op=or (nok + nok)
# {
# 'input' => {},
# 'name' => 'is.op=none (empty items)',
# 'schema' => [
# 'hash',
# 'is',
# [],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:hash) is.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 67 - (tags=clause:is, op, op:none, type, type:hash) is.op=none (empty items)
# {
# 'input' => {},
# 'name' => 'is.op=none (nok + nok)',
# 'schema' => [
# 'hash',
# 'is',
# [
# {
# 'a' => 1
# },
# {
# 'a' => 1
# }
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:hash) is.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 68 - (tags=clause:is, op, op:none, type, type:hash) is.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'is.op=none (nok + ok)',
# 'schema' => [
# 'hash',
# 'is',
# [
# {
# 'a' => 1
# },
# {}
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:hash) is.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 69 - (tags=clause:is, op, op:none, type, type:hash) is.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'is.op=none (ok + nok)',
# 'schema' => [
# 'hash',
# 'is',
# [
# {},
# {
# 'a' => 1
# }
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:hash) is.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 70 - (tags=clause:is, op, op:none, type, type:hash) is.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'is.op=none (ok + ok)',
# 'schema' => [
# 'hash',
# 'is',
# [
# {},
# {}
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:hash) is.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 71 - (tags=clause:is, op, op:none, type, type:hash) is.op=none (ok + ok)
# {
# 'input' => {},
# 'name' => 'in: must accept valid choices',
# 'schema' => [
# 'hash',
# 'in',
# [
# {},
# {
# 'a' => 1
# }
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, type, type:hash) in: must accept valid choices
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 72 - (tags=clause:in, type, type:hash) in: must accept valid choices
# {
# 'input' => {},
# 'name' => 'in: must reject empty choices',
# 'schema' => [
# 'hash',
# 'in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, type, type:hash) in: must reject empty choices
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 73 - (tags=clause:in, type, type:hash) in: must reject empty choices
# {
# 'input' => {},
# 'name' => '!in (nok)',
# 'schema' => [
# 'hash',
# '!in',
# [
# {},
# {
# 'a' => 1
# }
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:hash) !in (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 74 - (tags=clause:in, op, op:not, opshortcut, type, type:hash) !in (nok)
# {
# 'input' => {},
# 'name' => '!in (ok)',
# 'schema' => [
# 'hash',
# '!in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:hash) !in (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 75 - (tags=clause:in, op, op:not, opshortcut, type, type:hash) !in (ok)
# {
# 'input' => {},
# 'name' => 'in.op=not (nok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# {},
# {
# 'a' => 1
# }
# ],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, type, type:hash) in.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 76 - (tags=clause:in, op, op:not, type, type:hash) in.op=not (nok)
# {
# 'input' => {},
# 'name' => 'in.op=not (ok)',
# 'schema' => [
# 'hash',
# 'in',
# [],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, type, type:hash) in.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 77 - (tags=clause:in, op, op:not, type, type:hash) in.op=not (ok)
# {
# 'input' => {},
# 'name' => 'in& (no items)',
# 'schema' => [
# 'hash',
# 'in&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:hash) in& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 78 - (tags=clause:in, op, op:and, opshortcut, type, type:hash) in& (no items)
# {
# 'input' => {},
# 'name' => 'in& (ok)',
# 'schema' => [
# 'hash',
# 'in&',
# [
# [
# {},
# {
# 'a' => 1
# }
# ],
# [
# {},
# {
# 'a' => 1
# }
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:hash) in& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 79 - (tags=clause:in, op, op:and, opshortcut, type, type:hash) in& (ok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'in& (nok + ok)',
# 'schema' => [
# 'hash',
# 'in&',
# [
# [],
# [
# {},
# {
# 'a' => 1
# }
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:hash) in& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 80 - (tags=clause:in, op, op:and, opshortcut, type, type:hash) in& (nok + ok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'in& (ok + nok)',
# 'schema' => [
# 'hash',
# 'in&',
# [
# [
# {},
# {
# 'a' => 1
# }
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:hash) in& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 81 - (tags=clause:in, op, op:and, opshortcut, type, type:hash) in& (ok + nok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'in& (nok + nok)',
# 'schema' => [
# 'hash',
# 'in&',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:hash) in& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 82 - (tags=clause:in, op, op:and, opshortcut, type, type:hash) in& (nok + nok)
# {
# 'input' => {},
# 'name' => 'in.op=and (no items)',
# 'schema' => [
# 'hash',
# 'in',
# [],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:hash'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:hash) in.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 83 - (tags=type, type:hash) in.op=and (no items)
# {
# 'input' => {},
# 'name' => 'in.op=and (ok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# [
# {},
# {
# 'a' => 1
# }
# ],
# [
# {},
# {
# 'a' => 1
# }
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, type, type:hash) in.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 84 - (tags=clause:in, op, op:and, type, type:hash) in.op=and (ok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'in.op=and (nok + ok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# [],
# [
# {},
# {
# 'a' => 1
# }
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:hash) in.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 85 - (tags=clause:in, op, op:and, type, type:hash) in.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'in.op=and (ok + nok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# [
# {},
# {
# 'a' => 1
# }
# ],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:hash) in.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 86 - (tags=clause:in, op, op:and, type, type:hash) in.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'in.op=and (nok + nok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:hash) in.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 87 - (tags=clause:in, op, op:and, type, type:hash) in.op=and (nok + nok)
# {
# 'input' => {},
# 'name' => 'in| (no items)',
# 'schema' => [
# 'hash',
# 'in|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:hash) in| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 88 - (tags=clause:in, op, op:or, opshortcut, type, type:hash) in| (no items)
# {
# 'input' => {},
# 'name' => 'in| (ok)',
# 'schema' => [
# 'hash',
# 'in|',
# [
# [
# {},
# {
# 'a' => 1
# }
# ],
# [
# {},
# {
# 'a' => 1
# }
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:hash) in| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 89 - (tags=clause:in, op, op:or, opshortcut, type, type:hash) in| (ok)
# {
# 'input' => {},
# 'name' => 'in| (nok + ok)',
# 'schema' => [
# 'hash',
# 'in|',
# [
# [],
# [
# {},
# {
# 'a' => 1
# }
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:hash) in| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 90 - (tags=clause:in, op, op:or, opshortcut, type, type:hash) in| (nok + ok)
# {
# 'input' => {},
# 'name' => 'in| (ok + nok)',
# 'schema' => [
# 'hash',
# 'in|',
# [
# [
# {},
# {
# 'a' => 1
# }
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:hash) in| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 91 - (tags=clause:in, op, op:or, opshortcut, type, type:hash) in| (ok + nok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'in| (nok + nok)',
# 'schema' => [
# 'hash',
# 'in|',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:hash) in| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 92 - (tags=clause:in, op, op:or, opshortcut, type, type:hash) in| (nok + nok)
# {
# 'input' => {},
# 'name' => 'in.op=or (no items)',
# 'schema' => [
# 'hash',
# 'in',
# [],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:hash) in.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 93 - (tags=clause:in, op, op:or, type, type:hash) in.op=or (no items)
# {
# 'input' => {},
# 'name' => 'in.op=or (ok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# [
# {},
# {
# 'a' => 1
# }
# ],
# [
# {},
# {
# 'a' => 1
# }
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:hash) in.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 94 - (tags=clause:in, op, op:or, type, type:hash) in.op=or (ok)
# {
# 'input' => {},
# 'name' => 'in.op=or (nok + ok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# [],
# [
# {},
# {
# 'a' => 1
# }
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:hash) in.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 95 - (tags=clause:in, op, op:or, type, type:hash) in.op=or (nok + ok)
# {
# 'input' => {},
# 'name' => 'in.op=or (ok + nok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# [
# {},
# {
# 'a' => 1
# }
# ],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:hash) in.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 96 - (tags=clause:in, op, op:or, type, type:hash) in.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'in.op=or (nok + nok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, type, type:hash) in.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 97 - (tags=clause:in, op, op:or, type, type:hash) in.op=or (nok + nok)
# {
# 'input' => {},
# 'name' => 'in.op=none (empty items)',
# 'schema' => [
# 'hash',
# 'in',
# [],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:hash) in.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 98 - (tags=clause:in, op, op:none, type, type:hash) in.op=none (empty items)
# {
# 'input' => {},
# 'name' => 'in.op=none (nok + nok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:hash) in.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 99 - (tags=clause:in, op, op:none, type, type:hash) in.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'in.op=none (nok + ok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# [],
# [
# {},
# {
# 'a' => 1
# }
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:hash) in.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 100 - (tags=clause:in, op, op:none, type, type:hash) in.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'in.op=none (ok + nok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# [
# {},
# {
# 'a' => 1
# }
# ],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:hash) in.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 101 - (tags=clause:in, op, op:none, type, type:hash) in.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => {},
# 'name' => 'in.op=none (ok + ok)',
# 'schema' => [
# 'hash',
# 'in',
# [
# [
# {},
# {
# 'a' => 1
# }
# ],
# [
# {},
# {
# 'a' => 1
# }
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:hash) in.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 102 - (tags=clause:in, op, op:none, type, type:hash) in.op=none (ok + ok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'len (ok)',
# 'schema' => [
# 'hash',
# 'len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:len, type, type:hash) len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 103 - (tags=clause:len, type, type:hash) len (ok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'len (nok)',
# 'schema' => [
# 'hash',
# 'len',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:len, type, type:hash) len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 104 - (tags=clause:len, type, type:hash) len (nok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'min_len (ok)',
# 'schema' => [
# 'hash',
# 'min_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:min_len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min_len, type, type:hash) min_len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 105 - (tags=clause:min_len, type, type:hash) min_len (ok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'min_len (nok)',
# 'schema' => [
# 'hash',
# 'min_len',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:min_len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:min_len, type, type:hash) min_len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 106 - (tags=clause:min_len, type, type:hash) min_len (nok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'max_len (ok)',
# 'schema' => [
# 'hash',
# 'min_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:max_len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max_len, type, type:hash) max_len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 107 - (tags=clause:max_len, type, type:hash) max_len (ok)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1'
# },
# 'name' => 'max_len (nok)',
# 'schema' => [
# 'hash',
# 'max_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:max_len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:max_len, type, type:hash) max_len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 108 - (tags=clause:max_len, type, type:hash) max_len (nok)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'len_between (ok)',
# 'schema' => [
# 'hash',
# 'len_between',
# [
# 1,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:len_between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:len_between, type, type:hash) len_between (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 109 - (tags=clause:len_between, type, type:hash) len_between (ok)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1'
# },
# 'name' => 'len_between (nok)',
# 'schema' => [
# 'hash',
# 'len_between',
# [
# 1,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:len_between'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:len_between, type, type:hash) len_between (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 110 - (tags=clause:len_between, type, type:hash) len_between (nok)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1'
# },
# 'name' => 'each_index (ok)',
# 'schema' => [
# 'hash',
# 'each_index',
# [
# 'str',
# 'len',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:each_index'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:each_index, type, type:hash) each_index (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 111 - (tags=clause:each_index, type, type:hash) each_index (ok)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1'
# },
# 'name' => 'each_index (nok)',
# 'schema' => [
# 'hash',
# 'each_index',
# [
# 'str',
# 'len',
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:each_index'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:each_index, type, type:hash) each_index (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 112 - (tags=clause:each_index, type, type:hash) each_index (nok)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1'
# },
# 'name' => 'each_key (ok)',
# 'schema' => [
# 'hash',
# 'each_key',
# [
# 'str',
# 'len',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:each_key'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:each_key, type, type:hash) each_key (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 113 - (tags=clause:each_key, type, type:hash) each_key (ok)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1'
# },
# 'name' => 'each_key (nok)',
# 'schema' => [
# 'hash',
# 'each_key',
# [
# 'str',
# 'len',
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:each_key'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:each_key, type, type:hash) each_key (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 114 - (tags=clause:each_key, type, type:hash) each_key (nok)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1'
# },
# 'name' => 'each_elem (ok)',
# 'schema' => [
# 'hash',
# 'each_elem',
# 'float'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:each_elem'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:each_elem, type, type:hash) each_elem (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 115 - (tags=clause:each_elem, type, type:hash) each_elem (ok)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1'
# },
# 'name' => 'each_elem (nok)',
# 'schema' => [
# 'hash',
# 'each_elem',
# 'int'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:each_elem'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:each_elem, type, type:hash) each_elem (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 116 - (tags=clause:each_elem, type, type:hash) each_elem (nok)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1'
# },
# 'name' => 'each_value (ok)',
# 'schema' => [
# 'hash',
# 'each_value',
# 'float'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:each_value'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:each_value, type, type:hash) each_value (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 117 - (tags=clause:each_value, type, type:hash) each_value (ok)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1'
# },
# 'name' => 'each_value (nok)',
# 'schema' => [
# 'hash',
# 'each_value',
# 'int'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:each_value'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:each_value, type, type:hash) each_value (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 118 - (tags=clause:each_value, type, type:hash) each_value (nok)
# {
# 'invalid_inputs' => [
# {},
# {
# '3' => 'c'
# }
# ],
# 'name' => 'has',
# 'schema' => [
# 'hash',
# 'has',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:has'
# ],
# 'valid_inputs' => [
# {
# '1' => 'a',
# '2' => 'b',
# '3' => 'c'
# },
# {
# '1' => 'a',
# '3' => 'c'
# }
# ]
# }
# Subtest: (tags=clause:has, type, type:hash) has
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - validator (rt=full) returns hash
1..6
ok 119 - (tags=clause:has, type, type:hash) has
# {
# 'invalid_inputs' => [
# {
# '1' => 'a',
# '2' => 'b',
# '3' => 'c'
# },
# {
# '1' => 'a',
# '3' => 'c'
# }
# ],
# 'name' => 'has + op.not',
# 'schema' => [
# 'hash',
# '!has',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:has',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# {},
# {
# '3' => 'c'
# }
# ]
# }
# Subtest: (tags=clause:has, op, op:not, opshortcut, type, type:hash) has + op.not
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - validator (rt=full) returns hash
1..6
ok 120 - (tags=clause:has, op, op:not, opshortcut, type, type:hash) has + op.not
# {
# 'invalid_inputs' => [
# {},
# {
# '3' => 'c'
# }
# ],
# 'name' => 'has + op.or',
# 'schema' => [
# 'hash',
# 'has|',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:has',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# {
# '1' => 'a',
# '2' => 'b',
# '3' => 'c'
# },
# {
# '1' => 'a',
# '3' => 'c'
# }
# ]
# }
# Subtest: (tags=clause:has, op, op:or, opshortcut, type, type:hash) has + op.or
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - validator (rt=full) returns hash
1..6
ok 121 - (tags=clause:has, op, op:or, opshortcut, type, type:hash) has + op.or
# {
# 'invalid_inputs' => [
# {
# '1' => 'a',
# '3' => 'c'
# },
# {},
# {
# '3' => 'c'
# }
# ],
# 'name' => 'has + op.and',
# 'schema' => [
# 'hash',
# 'has&',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:has',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# {
# '1' => 'a',
# '2' => 'b',
# '3' => 'c'
# }
# ]
# }
# Subtest: (tags=clause:has, op, op:and, opshortcut, type, type:hash) has + op.and
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - invalid input [0]
ok 4 - invalid input [1]
ok 5 - invalid input [2]
ok 6 - validator (rt=full) returns hash
1..6
ok 122 - (tags=clause:has, op, op:and, opshortcut, type, type:hash) has + op.and
# {
# 'input' => {},
# 'name' => 'keys: (ok, empty)',
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => 'float*'
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:keys, type, type:hash) keys: (ok, empty)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 123 - (tags=clause:keys, type, type:hash) keys: (ok, empty)
# {
# 'input' => {
# 'a' => undef
# },
# 'name' => 'keys: (ok, only a, a valid 1)',
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => 'float*'
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:keys, type, type:hash) keys: (ok, only a, a valid 1)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 124 - (tags=clause:keys, type, type:hash) keys: (ok, only a, a valid 1)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'keys: (ok, only a, a valid 2)',
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => 'float*'
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:keys, type, type:hash) keys: (ok, only a, a valid 2)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 125 - (tags=clause:keys, type, type:hash) keys: (ok, only a, a valid 2)
# {
# 'input' => {
# 'a' => '1.1'
# },
# 'name' => 'keys: (nok, only a, a invalid)',
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => 'float*'
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:keys, type, type:hash) keys: (nok, only a, a invalid)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 126 - (tags=clause:keys, type, type:hash) keys: (nok, only a, a invalid)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'keys: (ok, only a, valid 2)',
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => 'float*'
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:keys, type, type:hash) keys: (ok, only a, valid 2)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 127 - (tags=clause:keys, type, type:hash) keys: (ok, only a, valid 2)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1'
# },
# 'name' => 'keys: (ok, a & b, valid)',
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => 'float*'
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:keys, type, type:hash) keys: (ok, a & b, valid)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 128 - (tags=clause:keys, type, type:hash) keys: (ok, a & b, valid)
# {
# 'input' => {
# 'a' => 1,
# 'b' => undef
# },
# 'name' => 'keys: (nok, a & b, b invalid)',
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => 'float*'
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:keys, type, type:hash) keys: (nok, a & b, b invalid)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 129 - (tags=clause:keys, type, type:hash) keys: (nok, a & b, b invalid)
# {
# 'input' => {
# 'a' => '1.1',
# 'b' => '1.1'
# },
# 'name' => 'keys: (nok, a & b, a invalid)',
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => 'float*'
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:keys, type, type:hash) keys: (nok, a & b, a invalid)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 130 - (tags=clause:keys, type, type:hash) keys: (nok, a & b, a invalid)
# {
# 'input' => {
# 'a' => '1.1',
# 'b' => undef
# },
# 'name' => 'keys: (nok, a & b, a & b invalid)',
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => 'float*'
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:keys, type, type:hash) keys: (nok, a & b, a & b invalid)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 131 - (tags=clause:keys, type, type:hash) keys: (nok, a & b, a & b invalid)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1',
# 'c' => 1
# },
# 'name' => 'keys: (nok, extra)',
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => 'float*'
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:keys, type, type:hash) keys: (nok, extra)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 132 - (tags=clause:keys, type, type:hash) keys: (nok, extra)
# {
# 'input' => {
# 'a' => 1,
# 'b' => '1.1',
# 'c' => 1
# },
# 'name' => 'keys: (ok, extra, restrict=0)',
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => 'float*'
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:keys, type, type:hash) keys: (ok, extra, restrict=0)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 133 - (tags=clause:keys, type, type:hash) keys: (ok, extra, restrict=0)
# {
# 'input' => {},
# 'name' => 'keys (create_default=1) 1',
# 'output' => {
# 'b' => 2
# },
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => [
# 'int',
# 'default',
# 2
# ]
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:keys, type, type:hash) keys (create_default=1) 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - output
ok 4 - valid (rt=str)
ok 5 - validator (rt=full) returns hash
ok 6 - errors (rt=full)
ok 7 - warnings (rt=full)
1..7
ok 134 - (tags=clause:keys, type, type:hash) keys (create_default=1) 1
# {
# 'input' => {
# 'b' => undef
# },
# 'name' => 'keys (create_default=1) 2',
# 'output' => {
# 'b' => 2
# },
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => [
# 'int',
# 'default',
# 2
# ]
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:keys, type, type:hash) keys (create_default=1) 2
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - output
ok 4 - valid (rt=str)
ok 5 - validator (rt=full) returns hash
ok 6 - errors (rt=full)
ok 7 - warnings (rt=full)
1..7
ok 135 - (tags=clause:keys, type, type:hash) keys (create_default=1) 2
# {
# 'input' => {},
# 'name' => 'keys (create_default=0) 1',
# 'output' => {},
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => [
# 'int',
# 'default',
# 2
# ]
# },
# 'keys.create_default' => 0
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:keys, type, type:hash) keys (create_default=0) 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - output
ok 4 - valid (rt=str)
ok 5 - validator (rt=full) returns hash
ok 6 - errors (rt=full)
ok 7 - warnings (rt=full)
1..7
ok 136 - (tags=clause:keys, type, type:hash) keys (create_default=0) 1
# {
# 'input' => {
# 'b' => undef
# },
# 'name' => 'keys (create_default=0) 2',
# 'output' => {
# 'b' => 2
# },
# 'schema' => [
# 'hash',
# {
# 'keys' => {
# 'a' => 'int',
# 'b' => [
# 'int',
# 'default',
# 2
# ]
# },
# 'keys.create_default' => 0
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:keys, type, type:hash) keys (create_default=0) 2
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - output
ok 4 - valid (rt=str)
ok 5 - validator (rt=full) returns hash
ok 6 - errors (rt=full)
ok 7 - warnings (rt=full)
1..7
ok 137 - (tags=clause:keys, type, type:hash) keys (create_default=0) 2
# {
# 'invalid_inputs' => [
# {
# 'a' => 'x'
# },
# {
# 'b' => 'x'
# },
# {
# 'c' => 1
# }
# ],
# 'name' => 're_keys',
# 'schema' => [
# 'hash',
# {
# 're_keys' => {
# '[ab]' => 'int'
# }
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:re_keys'
# ],
# 'valid_inputs' => [
# {},
# {
# 'a' => 1
# },
# {
# 'b' => 1
# }
# ]
# }
# Subtest: (tags=clause:re_keys, type, type:hash) re_keys
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - valid input [2]
ok 5 - invalid input [0]
ok 6 - invalid input [1]
ok 7 - invalid input [2]
ok 8 - validator (rt=full) returns hash
1..8
ok 138 - (tags=clause:re_keys, type, type:hash) re_keys
# {
# 'invalid_inputs' => [
# {
# 'a' => 'x'
# },
# {
# 'b' => 'x'
# }
# ],
# 'name' => 're_keys (restrict=0)',
# 'schema' => [
# 'hash',
# {
# 're_keys' => {
# '[ab]' => 'int'
# },
# 're_keys.restrict' => 0
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:re_keys'
# ],
# 'valid_inputs' => [
# {},
# {
# 'a' => 1
# },
# {
# 'b' => 1
# },
# {
# 'c' => 'x'
# }
# ]
# }
# Subtest: (tags=clause:re_keys, type, type:hash) re_keys (restrict=0)
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - valid input [2]
ok 5 - valid input [3]
ok 6 - invalid input [0]
ok 7 - invalid input [1]
ok 8 - validator (rt=full) returns hash
1..8
ok 139 - (tags=clause:re_keys, type, type:hash) re_keys (restrict=0)
# {
# 'input' => {},
# 'name' => 'req_keys: (ok, empty req_keys, empty keys in input)',
# 'schema' => [
# 'hash',
# {
# 'req_keys' => []
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:req_keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req_keys, type, type:hash) req_keys: (ok, empty req_keys, empty keys in input)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 140 - (tags=clause:req_keys, type, type:hash) req_keys: (ok, empty req_keys, empty keys in input)
# {
# 'input' => {
# 'a' => 1
# },
# 'name' => 'req_keys: (ok, empty req_keys, extra keys in input)',
# 'schema' => [
# 'hash',
# {
# 'req_keys' => []
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:req_keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req_keys, type, type:hash) req_keys: (ok, empty req_keys, extra keys in input)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 141 - (tags=clause:req_keys, type, type:hash) req_keys: (ok, empty req_keys, extra keys in input)
# {
# 'input' => {
# 'a' => 1,
# 'b' => 1
# },
# 'name' => 'req_keys: (ok)',
# 'schema' => [
# 'hash',
# {
# 'req_keys' => [
# 'a',
# 'b'
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:req_keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req_keys, type, type:hash) req_keys: (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 142 - (tags=clause:req_keys, type, type:hash) req_keys: (ok)
# {
# 'input' => {
# 'a' => 1,
# 'b' => 1,
# 'c' => 1
# },
# 'name' => 'req_keys: (ok, extra keys in input)',
# 'schema' => [
# 'hash',
# {
# 'req_keys' => [
# 'a',
# 'b'
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:req_keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req_keys, type, type:hash) req_keys: (ok, extra keys in input)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 143 - (tags=clause:req_keys, type, type:hash) req_keys: (ok, extra keys in input)
# {
# 'input' => {
# 'b' => 1,
# 'c' => 1
# },
# 'name' => 'req_keys: (nok, missing req keys in input)',
# 'schema' => [
# 'hash',
# {
# 'req_keys' => [
# 'a',
# 'b'
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:req_keys'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:req_keys, type, type:hash) req_keys: (nok, missing req keys in input)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 144 - (tags=clause:req_keys, type, type:hash) req_keys: (nok, missing req keys in input)
# {
# 'input' => {},
# 'name' => 'allowed_keys: (ok, empty keys in input)',
# 'schema' => [
# 'hash',
# {
# 'allowed_keys' => [
# 'a',
# 'b',
# 'c'
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:allowed_keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:allowed_keys, type, type:hash) allowed_keys: (ok, empty keys in input)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 145 - (tags=clause:allowed_keys, type, type:hash) allowed_keys: (ok, empty keys in input)
# {
# 'input' => {
# 'a' => 1,
# 'b' => undef
# },
# 'name' => 'allowed_keys: (ok)',
# 'schema' => [
# 'hash',
# {
# 'allowed_keys' => [
# 'a',
# 'b',
# 'c'
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:allowed_keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:allowed_keys, type, type:hash) allowed_keys: (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 146 - (tags=clause:allowed_keys, type, type:hash) allowed_keys: (ok)
# {
# 'input' => {
# 'a' => 1,
# 'd' => undef
# },
# 'name' => 'allowed_keys: (nok, keys outside allowed list)',
# 'schema' => [
# 'hash',
# {
# 'allowed_keys' => [
# 'a',
# 'b',
# 'c'
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:allowed_keys'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:allowed_keys, type, type:hash) allowed_keys: (nok, keys outside allowed list)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 147 - (tags=clause:allowed_keys, type, type:hash) allowed_keys: (nok, keys outside allowed list)
# {
# 'input' => {},
# 'name' => 'allowed_keys_re: (ok, empty keys in input)',
# 'schema' => [
# 'hash',
# {
# 'allowed_keys_re' => '^(a|b|c)$'
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:allowed_keys_re'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:allowed_keys_re, type, type:hash) allowed_keys_re: (ok, empty keys in input)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 148 - (tags=clause:allowed_keys_re, type, type:hash) allowed_keys_re: (ok, empty keys in input)
# {
# 'input' => {
# 'a' => 1,
# 'b' => undef
# },
# 'name' => 'allowed_keys_re: (ok)',
# 'schema' => [
# 'hash',
# {
# 'allowed_keys_re' => '^(a|b|c)$'
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:allowed_keys_re'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:allowed_keys_re, type, type:hash) allowed_keys_re: (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 149 - (tags=clause:allowed_keys_re, type, type:hash) allowed_keys_re: (ok)
# {
# 'input' => {
# 'a' => 1,
# 'd' => undef
# },
# 'name' => 'allowed_keys_re: (nok, keys outside allowed regex)',
# 'schema' => [
# 'hash',
# {
# 'allowed_keys_re' => '^(a|b|c)$'
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:allowed_keys_re'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:allowed_keys_re, type, type:hash) allowed_keys_re: (nok, keys outside allowed regex)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 150 - (tags=clause:allowed_keys_re, type, type:hash) allowed_keys_re: (nok, keys outside allowed regex)
# {
# 'input' => {},
# 'name' => 'forbidden_keys: (ok, empty keys in input)',
# 'schema' => [
# 'hash',
# {
# 'forbidden_keys' => [
# 'a',
# 'b',
# 'c'
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:forbidden_keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden_keys, type, type:hash) forbidden_keys: (ok, empty keys in input)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 151 - (tags=clause:forbidden_keys, type, type:hash) forbidden_keys: (ok, empty keys in input)
# {
# 'input' => {
# 'd' => 1,
# 'e' => undef
# },
# 'name' => 'forbidden_keys: (ok)',
# 'schema' => [
# 'hash',
# {
# 'forbidden_keys' => [
# 'a',
# 'b',
# 'c'
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:forbidden_keys'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden_keys, type, type:hash) forbidden_keys: (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 152 - (tags=clause:forbidden_keys, type, type:hash) forbidden_keys: (ok)
# {
# 'input' => {
# 'a' => 1,
# 'd' => undef
# },
# 'name' => 'forbidden_keys: (nok, keys in forbidden list)',
# 'schema' => [
# 'hash',
# {
# 'forbidden_keys' => [
# 'a',
# 'b',
# 'c'
# ]
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:forbidden_keys'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:forbidden_keys, type, type:hash) forbidden_keys: (nok, keys in forbidden list)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 153 - (tags=clause:forbidden_keys, type, type:hash) forbidden_keys: (nok, keys in forbidden list)
# {
# 'input' => {},
# 'name' => 'forbidden_keys_re: (ok, empty keys in input)',
# 'schema' => [
# 'hash',
# {
# 'forbidden_keys_re' => '^(a|b|c)$'
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:forbidden_keys_re'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden_keys_re, type, type:hash) forbidden_keys_re: (ok, empty keys in input)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 154 - (tags=clause:forbidden_keys_re, type, type:hash) forbidden_keys_re: (ok, empty keys in input)
# {
# 'input' => {
# 'd' => 1,
# 'e' => undef
# },
# 'name' => 'forbidden_keys_re: (ok)',
# 'schema' => [
# 'hash',
# {
# 'forbidden_keys_re' => '^(a|b|c)$'
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:forbidden_keys_re'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden_keys_re, type, type:hash) forbidden_keys_re: (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 155 - (tags=clause:forbidden_keys_re, type, type:hash) forbidden_keys_re: (ok)
# {
# 'input' => {
# 'a' => 1,
# 'd' => undef
# },
# 'name' => 'forbidden_keys_re: (nok, keys in forbidden regex)',
# 'schema' => [
# 'hash',
# {
# 'forbidden_keys_re' => '^(a|b|c)$'
# }
# ],
# 'tags' => [
# 'type',
# 'type:hash',
# 'clause:forbidden_keys_re'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:forbidden_keys_re, type, type:hash) forbidden_keys_re: (nok, keys in forbidden regex)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 156 - (tags=clause:forbidden_keys_re, type, type:hash) forbidden_keys_re: (nok, keys in forbidden regex)
ok 157
1..157
ok 10 - 10-type-hash.json
# Subtest: 10-type-int.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => -1,
# 'name' => 'type check: must accept -1',
# 'schema' => 'int',
# 'tags' => [
# 'type',
# 'type:int'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:int) type check: must accept -1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=type, type:int) type check: must accept -1
# {
# 'input' => 0,
# 'name' => 'type check: must accept 0',
# 'schema' => 'int',
# 'tags' => [
# 'type',
# 'type:int'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:int) type check: must accept 0
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=type, type:int) type check: must accept 0
# {
# 'input' => 1,
# 'name' => 'type check: must accept 1',
# 'schema' => 'int',
# 'tags' => [
# 'type',
# 'type:int'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:int) type check: must accept 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 3 - (tags=type, type:int) type check: must accept 1
# {
# 'input' => '1.1',
# 'name' => 'type check: must reject 1.1',
# 'schema' => 'int',
# 'tags' => [
# 'type',
# 'type:int'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:int) type check: must reject 1.1
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 4 - (tags=type, type:int) type check: must reject 1.1
# {
# 'input' => 'a',
# 'name' => 'type check: must reject a',
# 'schema' => 'int',
# 'tags' => [
# 'type',
# 'type:int'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:int) type check: must reject a
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 5 - (tags=type, type:int) type check: must reject a
# {
# 'input' => [],
# 'name' => 'type check: must reject []',
# 'schema' => 'int',
# 'tags' => [
# 'type',
# 'type:int'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:int) type check: must reject []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 6 - (tags=type, type:int) type check: must reject []
# {
# 'input' => {},
# 'name' => 'type check: must reject {}',
# 'schema' => 'int',
# 'tags' => [
# 'type',
# 'type:int'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:int) type check: must reject {}
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 7 - (tags=type, type:int) type check: must reject {}
# {
# 'input' => undef,
# 'name' => 'must accept undefined value',
# 'schema' => 'int',
# 'tags' => [
# 'type',
# 'type:int'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:int) must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 8 - (tags=type, type:int) must accept undefined value
# {
# 'input' => undef,
# 'name' => 'defhash_v',
# 'schema' => [
# 'int',
# 'defhash_v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:defhash_v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:defhash_v, type, type:int) defhash_v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 9 - (tags=clause:defhash_v, type, type:int) defhash_v
# {
# 'input' => undef,
# 'name' => 'v',
# 'schema' => [
# 'int',
# 'v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:v, type, type:int) v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 10 - (tags=clause:v, type, type:int) v
# {
# 'input' => undef,
# 'name' => 'c',
# 'schema' => [
# 'int',
# 'c.foo.bar',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:c'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:c, type, type:int) c
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 11 - (tags=clause:c, type, type:int) c
# {
# 'input' => undef,
# 'name' => 'default_lang',
# 'schema' => [
# 'int',
# 'default_lang',
# 'id_ID'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:default_lang'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default_lang, type, type:int) default_lang
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 12 - (tags=clause:default_lang, type, type:int) default_lang
# {
# 'input' => undef,
# 'name' => 'name',
# 'schema' => [
# 'int',
# 'name',
# 'some name'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:name'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:name, type, type:int) name
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 13 - (tags=clause:name, type, type:int) name
# {
# 'input' => undef,
# 'name' => 'summary',
# 'schema' => [
# 'int',
# 'summary',
# 'some summary'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:summary'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:summary, type, type:int) summary
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 14 - (tags=clause:summary, type, type:int) summary
# {
# 'input' => undef,
# 'name' => 'description',
# 'schema' => [
# 'int',
# 'description',
# 'some description and `markdown`'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:description'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:description, type, type:int) description
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 15 - (tags=clause:description, type, type:int) description
# {
# 'input' => undef,
# 'name' => 'tags',
# 'schema' => [
# 'int',
# 'tags',
# [
# 'some',
# 'tags'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:tags'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:tags, type, type:int) tags
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 16 - (tags=clause:tags, type, type:int) tags
# {
# 'input' => undef,
# 'name' => 'req=0 must accept undefined value',
# 'schema' => [
# 'int',
# 'req',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:req'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req, type, type:int) req=0 must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 17 - (tags=clause:req, type, type:int) req=0 must accept undefined value
# {
# 'input' => undef,
# 'name' => 'req=1 must reject undefined value',
# 'schema' => [
# 'int',
# 'req',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:req'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:req, type, type:int) req=1 must reject undefined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 18 - (tags=clause:req, type, type:int) req=1 must reject undefined value
# {
# 'input' => 2,
# 'name' => 'forbidden=0 must accept defined value',
# 'schema' => [
# 'int',
# 'forbidden',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:forbidden'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden, type, type:int) forbidden=0 must accept defined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 19 - (tags=clause:forbidden, type, type:int) forbidden=0 must accept defined value
# {
# 'input' => 2,
# 'name' => 'forbidden=1 must reject defined value',
# 'schema' => [
# 'int',
# 'forbidden',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:forbidden'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:forbidden, type, type:int) forbidden=1 must reject defined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 20 - (tags=clause:forbidden, type, type:int) forbidden=1 must reject defined value
# {
# 'input' => undef,
# 'name' => 'default: must accept valid default 1',
# 'schema' => [
# 'int*',
# 'default',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:default'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default, type, type:int) default: must accept valid default 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 21 - (tags=clause:default, type, type:int) default: must accept valid default 1
# {
# 'input' => undef,
# 'name' => 'default: must reject invalid default []',
# 'schema' => [
# 'int*',
# 'default',
# []
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:default'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:default, type, type:int) default: must reject invalid default []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 22 - (tags=clause:default, type, type:int) default: must reject invalid default []
# {
# 'dies' => 1,
# 'input' => 2,
# 'name' => 'clause (dies, unknown clause)',
# 'schema' => [
# 'int*',
# 'clause',
# [
# 'foo',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:clause'
# ]
# }
# Subtest: (tags=clause:clause, type, type:int) clause (dies, unknown clause)
ok 1 - compile error
1..1
ok 23 - (tags=clause:clause, type, type:int) clause (dies, unknown clause)
# {
# 'input' => 2,
# 'name' => 'clause (ok)',
# 'schema' => [
# 'int*',
# 'clause',
# [
# 'min',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:clause'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clause, type, type:int) clause (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 24 - (tags=clause:clause, type, type:int) clause (ok)
# {
# 'input' => 2,
# 'name' => 'clause (ok) + clause nok = nok',
# 'schema' => [
# 'int*',
# 'clause',
# [
# 'min',
# 1
# ],
# 'xmax',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:int) clause (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 25 - (tags=clause:clause, type, type:int) clause (ok) + clause nok = nok
# {
# 'errors' => 1,
# 'input' => 2,
# 'name' => 'clause (nok)',
# 'schema' => [
# 'int*',
# 'clause',
# [
# 'min',
# 3
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:int) clause (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 26 - (tags=clause:clause, type, type:int) clause (nok)
# {
# 'dies' => 1,
# 'input' => 2,
# 'name' => 'clset (dies, unknown clause)',
# 'schema' => [
# 'int*',
# 'clset',
# {
# 'foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:int) clset (dies, unknown clause)
ok 1 - compile error
1..1
ok 27 - (tags=clause:clset, type, type:int) clset (dies, unknown clause)
# {
# 'dies' => 1,
# 'input' => 2,
# 'name' => 'clset (dies, unknown attr)',
# 'schema' => [
# 'int*',
# 'clset',
# {
# 'min_len' => 1,
# 'min_len.foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:int) clset (dies, unknown attr)
ok 1 - compile error
1..1
ok 28 - (tags=clause:clset, type, type:int) clset (dies, unknown attr)
# {
# 'input' => 2,
# 'name' => 'clset (empty = ok)',
# 'schema' => [
# 'int*',
# 'clset',
# {}
# ],
# 'tags' => [
# 'type',
# 'type:int'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:int) clset (empty = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 29 - (tags=type, type:int) clset (empty = ok)
# {
# 'input' => 2,
# 'name' => 'clset (ignored clause/attr = ok)',
# 'schema' => [
# 'int*',
# 'clset',
# {
# '_foo' => 1,
# 'foo._bar' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:int) clset (ignored clause/attr = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 30 - (tags=clause:clset, type, type:int) clset (ignored clause/attr = ok)
# {
# 'input' => 2,
# 'name' => 'clset (ok + ok = ok)',
# 'schema' => [
# 'int*',
# 'clset',
# {
# 'max' => 2,
# 'min' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:int) clset (ok + ok = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 31 - (tags=clause:clset, type, type:int) clset (ok + ok = ok)
# {
# 'input' => 2,
# 'name' => 'clset (ok) + clause nok = nok',
# 'schema' => [
# 'int*',
# 'clset',
# {
# 'min' => 1
# },
# 'xmax',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:int) clset (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 32 - (tags=clause:clset, type, type:int) clset (ok) + clause nok = nok
# {
# 'input' => 2,
# 'name' => 'clset (ok + nok = nok)',
# 'schema' => [
# 'int*',
# 'clset',
# {
# 'min' => 1,
# 'xmax' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:int) clset (ok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 33 - (tags=clause:clset, type, type:int) clset (ok + nok = nok)
# {
# 'input' => 2,
# 'name' => 'clset (nok + ok = nok)',
# 'schema' => [
# 'int*',
# 'clset',
# {
# 'max' => 2,
# 'min' => 3
# }
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:int) clset (nok + ok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 34 - (tags=clause:clset, type, type:int) clset (nok + ok = nok)
# {
# 'input' => 2,
# 'name' => 'clset (nok + nok = nok)',
# 'schema' => [
# 'int*',
# 'clset',
# {
# 'min' => 3,
# 'xmax' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:int) clset (nok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 35 - (tags=clause:clset, type, type:int) clset (nok + nok = nok)
# {
# 'input' => undef,
# 'name' => 'ok',
# 'schema' => [
# 'int',
# {
# 'ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:ok'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:ok, type, type:int) ok
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 36 - (tags=clause:ok, type, type:int) ok
# {
# 'input' => undef,
# 'name' => 'ok + op not (nok)',
# 'schema' => [
# 'int',
# {
# '!ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:ok',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:ok, op, op:not, type, type:int) ok + op not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 37 - (tags=clause:ok, op, op:not, type, type:int) ok + op not (nok)
# {
# 'input' => 9,
# 'name' => '.err_level=error (clause=div_by, ok)',
# 'schema' => [
# 'int',
# 'div_by',
# 3
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:int) .err_level=error (clause=div_by, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 38 - (tags=attr, attr:err_level, type, type:int) .err_level=error (clause=div_by, ok)
# {
# 'input' => 8,
# 'name' => '.err_level=error (clause=div_by, nok)',
# 'schema' => [
# 'int',
# 'div_by',
# 3
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 0
# }
# Subtest: (tags=attr, attr:err_level, type, type:int) .err_level=error (clause=div_by, nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 39 - (tags=attr, attr:err_level, type, type:int) .err_level=error (clause=div_by, nok)
# {
# 'input' => 9,
# 'name' => '.err_level=warn (clause=div_by, ok)',
# 'schema' => [
# 'int',
# 'div_by',
# 3,
# 'div_by.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:int) .err_level=warn (clause=div_by, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 40 - (tags=attr, attr:err_level, type, type:int) .err_level=warn (clause=div_by, ok)
# {
# 'input' => 8,
# 'name' => '.err_level=warn (clause=div_by, nok)',
# 'schema' => [
# 'int*',
# 'div_by',
# 3,
# 'div_by.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1,
# 'warnings' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:int) .err_level=warn (clause=div_by, nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 41 - (tags=attr, attr:err_level, type, type:int) .err_level=warn (clause=div_by, nok)
# {
# 'input' => 1,
# 'name' => 'is: must accept same value',
# 'schema' => [
# 'int',
# 'is',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, type, type:int) is: must accept same value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 42 - (tags=clause:is, type, type:int) is: must accept same value
# {
# 'input' => 1,
# 'name' => 'is: must reject different value',
# 'schema' => [
# 'int',
# 'is',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, type, type:int) is: must reject different value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 43 - (tags=clause:is, type, type:int) is: must reject different value
# {
# 'input' => 1,
# 'name' => '!is (nok)',
# 'schema' => [
# 'int',
# '!is',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:int) !is (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 44 - (tags=clause:is, op, op:not, opshortcut, type, type:int) !is (nok)
# {
# 'input' => 1,
# 'name' => '!is (ok)',
# 'schema' => [
# 'int',
# '!is',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:int) !is (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 45 - (tags=clause:is, op, op:not, opshortcut, type, type:int) !is (ok)
# {
# 'input' => 1,
# 'name' => 'is.op=not (nok)',
# 'schema' => [
# 'int',
# 'is',
# 1,
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, type, type:int) is.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 46 - (tags=clause:is, op, op:not, type, type:int) is.op=not (nok)
# {
# 'input' => 1,
# 'name' => 'is.op=not (ok)',
# 'schema' => [
# 'int',
# 'is',
# 2,
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, type, type:int) is.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 47 - (tags=clause:is, op, op:not, type, type:int) is.op=not (ok)
# {
# 'input' => 1,
# 'name' => 'is& (no items)',
# 'schema' => [
# 'int',
# 'is&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:int) is& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 48 - (tags=clause:is, op, op:and, opshortcut, type, type:int) is& (no items)
# {
# 'input' => 1,
# 'name' => 'is& (ok)',
# 'schema' => [
# 'int',
# 'is&',
# [
# 1,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:int) is& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 49 - (tags=clause:is, op, op:and, opshortcut, type, type:int) is& (ok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'is& (nok + ok)',
# 'schema' => [
# 'int',
# 'is&',
# [
# 2,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:int) is& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 50 - (tags=clause:is, op, op:and, opshortcut, type, type:int) is& (nok + ok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'is& (ok + nok)',
# 'schema' => [
# 'int',
# 'is&',
# [
# 1,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:int) is& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 51 - (tags=clause:is, op, op:and, opshortcut, type, type:int) is& (ok + nok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'is& (nok + nok)',
# 'schema' => [
# 'int',
# 'is&',
# [
# 2,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:int) is& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 52 - (tags=clause:is, op, op:and, opshortcut, type, type:int) is& (nok + nok)
# {
# 'input' => 1,
# 'name' => 'is.op=and (no items)',
# 'schema' => [
# 'int',
# 'is',
# [],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:int) is.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 53 - (tags=type, type:int) is.op=and (no items)
# {
# 'input' => 1,
# 'name' => 'is.op=and (ok)',
# 'schema' => [
# 'int',
# 'is',
# [
# 1,
# 1
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, type, type:int) is.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 54 - (tags=clause:is, op, op:and, type, type:int) is.op=and (ok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'is.op=and (nok + ok)',
# 'schema' => [
# 'int',
# 'is',
# [
# 2,
# 1
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:int) is.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 55 - (tags=clause:is, op, op:and, type, type:int) is.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'is.op=and (ok + nok)',
# 'schema' => [
# 'int',
# 'is',
# [
# 1,
# 2
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:int) is.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 56 - (tags=clause:is, op, op:and, type, type:int) is.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'is.op=and (nok + nok)',
# 'schema' => [
# 'int',
# 'is',
# [
# 2,
# 2
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:int) is.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 57 - (tags=clause:is, op, op:and, type, type:int) is.op=and (nok + nok)
# {
# 'input' => 1,
# 'name' => 'is| (no items)',
# 'schema' => [
# 'int',
# 'is|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:int) is| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 58 - (tags=clause:is, op, op:or, opshortcut, type, type:int) is| (no items)
# {
# 'input' => 1,
# 'name' => 'is| (ok)',
# 'schema' => [
# 'int',
# 'is|',
# [
# 1,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:int) is| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 59 - (tags=clause:is, op, op:or, opshortcut, type, type:int) is| (ok)
# {
# 'input' => 1,
# 'name' => 'is| (nok + ok)',
# 'schema' => [
# 'int',
# 'is|',
# [
# 2,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:int) is| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 60 - (tags=clause:is, op, op:or, opshortcut, type, type:int) is| (nok + ok)
# {
# 'input' => 1,
# 'name' => 'is| (ok + nok)',
# 'schema' => [
# 'int',
# 'is|',
# [
# 1,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:int) is| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 61 - (tags=clause:is, op, op:or, opshortcut, type, type:int) is| (ok + nok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'is| (nok + nok)',
# 'schema' => [
# 'int',
# 'is|',
# [
# 2,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:int) is| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 62 - (tags=clause:is, op, op:or, opshortcut, type, type:int) is| (nok + nok)
# {
# 'input' => 1,
# 'name' => 'is.op=or (no items)',
# 'schema' => [
# 'int',
# 'is',
# [],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:int) is.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 63 - (tags=clause:is, op, op:or, type, type:int) is.op=or (no items)
# {
# 'input' => 1,
# 'name' => 'is.op=or (ok)',
# 'schema' => [
# 'int',
# 'is',
# [
# 1,
# 1
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:int) is.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 64 - (tags=clause:is, op, op:or, type, type:int) is.op=or (ok)
# {
# 'input' => 1,
# 'name' => 'is.op=or (nok + ok)',
# 'schema' => [
# 'int',
# 'is',
# [
# 2,
# 1
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:int) is.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 65 - (tags=clause:is, op, op:or, type, type:int) is.op=or (nok + ok)
# {
# 'input' => 1,
# 'name' => 'is.op=or (ok + nok)',
# 'schema' => [
# 'int',
# 'is',
# [
# 1,
# 2
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:int) is.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 66 - (tags=clause:is, op, op:or, type, type:int) is.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'is.op=or (nok + nok)',
# 'schema' => [
# 'int',
# 'is',
# [
# 2,
# 2
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, type, type:int) is.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 67 - (tags=clause:is, op, op:or, type, type:int) is.op=or (nok + nok)
# {
# 'input' => 1,
# 'name' => 'is.op=none (empty items)',
# 'schema' => [
# 'int',
# 'is',
# [],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:int) is.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 68 - (tags=clause:is, op, op:none, type, type:int) is.op=none (empty items)
# {
# 'input' => 1,
# 'name' => 'is.op=none (nok + nok)',
# 'schema' => [
# 'int',
# 'is',
# [
# 2,
# 2
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:int) is.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 69 - (tags=clause:is, op, op:none, type, type:int) is.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'is.op=none (nok + ok)',
# 'schema' => [
# 'int',
# 'is',
# [
# 2,
# 1
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:int) is.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 70 - (tags=clause:is, op, op:none, type, type:int) is.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'is.op=none (ok + nok)',
# 'schema' => [
# 'int',
# 'is',
# [
# 1,
# 2
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:int) is.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 71 - (tags=clause:is, op, op:none, type, type:int) is.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'is.op=none (ok + ok)',
# 'schema' => [
# 'int',
# 'is',
# [
# 1,
# 1
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:int) is.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 72 - (tags=clause:is, op, op:none, type, type:int) is.op=none (ok + ok)
# {
# 'input' => 1,
# 'name' => 'in: must accept valid choices',
# 'schema' => [
# 'int',
# 'in',
# [
# 1,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, type, type:int) in: must accept valid choices
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 73 - (tags=clause:in, type, type:int) in: must accept valid choices
# {
# 'input' => 1,
# 'name' => 'in: must reject empty choices',
# 'schema' => [
# 'int',
# 'in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, type, type:int) in: must reject empty choices
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 74 - (tags=clause:in, type, type:int) in: must reject empty choices
# {
# 'input' => 1,
# 'name' => '!in (nok)',
# 'schema' => [
# 'int',
# '!in',
# [
# 1,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:int) !in (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 75 - (tags=clause:in, op, op:not, opshortcut, type, type:int) !in (nok)
# {
# 'input' => 1,
# 'name' => '!in (ok)',
# 'schema' => [
# 'int',
# '!in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:int) !in (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 76 - (tags=clause:in, op, op:not, opshortcut, type, type:int) !in (ok)
# {
# 'input' => 1,
# 'name' => 'in.op=not (nok)',
# 'schema' => [
# 'int',
# 'in',
# [
# 1,
# 2
# ],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, type, type:int) in.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 77 - (tags=clause:in, op, op:not, type, type:int) in.op=not (nok)
# {
# 'input' => 1,
# 'name' => 'in.op=not (ok)',
# 'schema' => [
# 'int',
# 'in',
# [],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, type, type:int) in.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 78 - (tags=clause:in, op, op:not, type, type:int) in.op=not (ok)
# {
# 'input' => 1,
# 'name' => 'in& (no items)',
# 'schema' => [
# 'int',
# 'in&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:int) in& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 79 - (tags=clause:in, op, op:and, opshortcut, type, type:int) in& (no items)
# {
# 'input' => 1,
# 'name' => 'in& (ok)',
# 'schema' => [
# 'int',
# 'in&',
# [
# [
# 1,
# 2
# ],
# [
# 1,
# 2
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:int) in& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 80 - (tags=clause:in, op, op:and, opshortcut, type, type:int) in& (ok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'in& (nok + ok)',
# 'schema' => [
# 'int',
# 'in&',
# [
# [],
# [
# 1,
# 2
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:int) in& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 81 - (tags=clause:in, op, op:and, opshortcut, type, type:int) in& (nok + ok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'in& (ok + nok)',
# 'schema' => [
# 'int',
# 'in&',
# [
# [
# 1,
# 2
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:int) in& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 82 - (tags=clause:in, op, op:and, opshortcut, type, type:int) in& (ok + nok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'in& (nok + nok)',
# 'schema' => [
# 'int',
# 'in&',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:int) in& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 83 - (tags=clause:in, op, op:and, opshortcut, type, type:int) in& (nok + nok)
# {
# 'input' => 1,
# 'name' => 'in.op=and (no items)',
# 'schema' => [
# 'int',
# 'in',
# [],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:int) in.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 84 - (tags=type, type:int) in.op=and (no items)
# {
# 'input' => 1,
# 'name' => 'in.op=and (ok)',
# 'schema' => [
# 'int',
# 'in',
# [
# [
# 1,
# 2
# ],
# [
# 1,
# 2
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, type, type:int) in.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 85 - (tags=clause:in, op, op:and, type, type:int) in.op=and (ok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'in.op=and (nok + ok)',
# 'schema' => [
# 'int',
# 'in',
# [
# [],
# [
# 1,
# 2
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:int) in.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 86 - (tags=clause:in, op, op:and, type, type:int) in.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'in.op=and (ok + nok)',
# 'schema' => [
# 'int',
# 'in',
# [
# [
# 1,
# 2
# ],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:int) in.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 87 - (tags=clause:in, op, op:and, type, type:int) in.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'in.op=and (nok + nok)',
# 'schema' => [
# 'int',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:int) in.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 88 - (tags=clause:in, op, op:and, type, type:int) in.op=and (nok + nok)
# {
# 'input' => 1,
# 'name' => 'in| (no items)',
# 'schema' => [
# 'int',
# 'in|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:int) in| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 89 - (tags=clause:in, op, op:or, opshortcut, type, type:int) in| (no items)
# {
# 'input' => 1,
# 'name' => 'in| (ok)',
# 'schema' => [
# 'int',
# 'in|',
# [
# [
# 1,
# 2
# ],
# [
# 1,
# 2
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:int) in| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 90 - (tags=clause:in, op, op:or, opshortcut, type, type:int) in| (ok)
# {
# 'input' => 1,
# 'name' => 'in| (nok + ok)',
# 'schema' => [
# 'int',
# 'in|',
# [
# [],
# [
# 1,
# 2
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:int) in| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 91 - (tags=clause:in, op, op:or, opshortcut, type, type:int) in| (nok + ok)
# {
# 'input' => 1,
# 'name' => 'in| (ok + nok)',
# 'schema' => [
# 'int',
# 'in|',
# [
# [
# 1,
# 2
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:int) in| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 92 - (tags=clause:in, op, op:or, opshortcut, type, type:int) in| (ok + nok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'in| (nok + nok)',
# 'schema' => [
# 'int',
# 'in|',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:int) in| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 93 - (tags=clause:in, op, op:or, opshortcut, type, type:int) in| (nok + nok)
# {
# 'input' => 1,
# 'name' => 'in.op=or (no items)',
# 'schema' => [
# 'int',
# 'in',
# [],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:int) in.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 94 - (tags=clause:in, op, op:or, type, type:int) in.op=or (no items)
# {
# 'input' => 1,
# 'name' => 'in.op=or (ok)',
# 'schema' => [
# 'int',
# 'in',
# [
# [
# 1,
# 2
# ],
# [
# 1,
# 2
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:int) in.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 95 - (tags=clause:in, op, op:or, type, type:int) in.op=or (ok)
# {
# 'input' => 1,
# 'name' => 'in.op=or (nok + ok)',
# 'schema' => [
# 'int',
# 'in',
# [
# [],
# [
# 1,
# 2
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:int) in.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 96 - (tags=clause:in, op, op:or, type, type:int) in.op=or (nok + ok)
# {
# 'input' => 1,
# 'name' => 'in.op=or (ok + nok)',
# 'schema' => [
# 'int',
# 'in',
# [
# [
# 1,
# 2
# ],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:int) in.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 97 - (tags=clause:in, op, op:or, type, type:int) in.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'in.op=or (nok + nok)',
# 'schema' => [
# 'int',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, type, type:int) in.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 98 - (tags=clause:in, op, op:or, type, type:int) in.op=or (nok + nok)
# {
# 'input' => 1,
# 'name' => 'in.op=none (empty items)',
# 'schema' => [
# 'int',
# 'in',
# [],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:int) in.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 99 - (tags=clause:in, op, op:none, type, type:int) in.op=none (empty items)
# {
# 'input' => 1,
# 'name' => 'in.op=none (nok + nok)',
# 'schema' => [
# 'int',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:int) in.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 100 - (tags=clause:in, op, op:none, type, type:int) in.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'in.op=none (nok + ok)',
# 'schema' => [
# 'int',
# 'in',
# [
# [],
# [
# 1,
# 2
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:int) in.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 101 - (tags=clause:in, op, op:none, type, type:int) in.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'in.op=none (ok + nok)',
# 'schema' => [
# 'int',
# 'in',
# [
# [
# 1,
# 2
# ],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:int) in.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 102 - (tags=clause:in, op, op:none, type, type:int) in.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => 1,
# 'name' => 'in.op=none (ok + ok)',
# 'schema' => [
# 'int',
# 'in',
# [
# [
# 1,
# 2
# ],
# [
# 1,
# 2
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:int) in.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 103 - (tags=clause:in, op, op:none, type, type:int) in.op=none (ok + ok)
# {
# 'input' => 2,
# 'name' => 'min: 2 -3',
# 'schema' => [
# 'int',
# 'min',
# -3
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:int) min: 2 -3
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 104 - (tags=clause:min, type, type:int) min: 2 -3
# {
# 'input' => 2,
# 'name' => 'min: 2 2',
# 'schema' => [
# 'int',
# 'min',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:int) min: 2 2
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 105 - (tags=clause:min, type, type:int) min: 2 2
# {
# 'input' => -3,
# 'name' => 'min: -3 2 -> fail',
# 'schema' => [
# 'int',
# 'min',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:min'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:min, type, type:int) min: -3 2 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 106 - (tags=clause:min, type, type:int) min: -3 2 -> fail
# {
# 'input' => 2,
# 'name' => 'xmin: 2 -3',
# 'schema' => [
# 'int',
# 'xmin',
# -3
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:xmin'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmin, type, type:int) xmin: 2 -3
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 107 - (tags=clause:xmin, type, type:int) xmin: 2 -3
# {
# 'input' => 2,
# 'name' => 'xmin: 2 2 -> fail',
# 'schema' => [
# 'int',
# 'xmin',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:int) xmin: 2 2 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 108 - (tags=clause:xmin, type, type:int) xmin: 2 2 -> fail
# {
# 'input' => -3,
# 'name' => 'xmin: -3 2 -> fail',
# 'schema' => [
# 'int',
# 'xmin',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:int) xmin: -3 2 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 109 - (tags=clause:xmin, type, type:int) xmin: -3 2 -> fail
# {
# 'input' => 2,
# 'name' => 'max: 2 -3 -> fail',
# 'schema' => [
# 'int',
# 'max',
# -3
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:max'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:max, type, type:int) max: 2 -3 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 110 - (tags=clause:max, type, type:int) max: 2 -3 -> fail
# {
# 'input' => 2,
# 'name' => 'max: 2 2',
# 'schema' => [
# 'int',
# 'max',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:int) max: 2 2
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 111 - (tags=clause:max, type, type:int) max: 2 2
# {
# 'input' => -3,
# 'name' => 'max: -3 2',
# 'schema' => [
# 'int',
# 'max',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:int) max: -3 2
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 112 - (tags=clause:max, type, type:int) max: -3 2
# {
# 'input' => 2,
# 'name' => 'xmax: 2 -3 -> fail',
# 'schema' => [
# 'int',
# 'xmax',
# -3
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:int) xmax: 2 -3 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 113 - (tags=clause:xmax, type, type:int) xmax: 2 -3 -> fail
# {
# 'input' => 2,
# 'name' => 'xmax: 2 2 -> fail',
# 'schema' => [
# 'int',
# 'xmax',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:int) xmax: 2 2 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 114 - (tags=clause:xmax, type, type:int) xmax: 2 2 -> fail
# {
# 'input' => -3,
# 'name' => 'xmax: -3 2',
# 'schema' => [
# 'int',
# 'xmax',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:xmax'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmax, type, type:int) xmax: -3 2
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 115 - (tags=clause:xmax, type, type:int) xmax: -3 2
# {
# 'input' => 2,
# 'name' => 'between: 2 -3 & 4',
# 'schema' => [
# 'int',
# 'between',
# [
# -3,
# 4
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:int) between: 2 -3 & 4
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 116 - (tags=clause:between, type, type:int) between: 2 -3 & 4
# {
# 'input' => 2,
# 'name' => 'between: 2 -3 & 2',
# 'schema' => [
# 'int',
# 'between',
# [
# -3,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:int) between: 2 -3 & 2
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 117 - (tags=clause:between, type, type:int) between: 2 -3 & 2
# {
# 'input' => 2,
# 'name' => 'between: 2 2 & 2',
# 'schema' => [
# 'int',
# 'between',
# [
# 2,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:int) between: 2 2 & 2
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 118 - (tags=clause:between, type, type:int) between: 2 2 & 2
# {
# 'input' => -3,
# 'name' => 'between: -3 2 & 4 -> fail',
# 'schema' => [
# 'int',
# 'between',
# [
# 2,
# 4
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, type, type:int) between: -3 2 & 4 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 119 - (tags=clause:between, type, type:int) between: -3 2 & 4 -> fail
# {
# 'input' => '2',
# 'name' => 'xbetween: 2 -3 & 4',
# 'schema' => [
# 'int',
# 'xbetween',
# [
# -3,
# 4
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:xbetween'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xbetween, type, type:int) xbetween: 2 -3 & 4
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 120 - (tags=clause:xbetween, type, type:int) xbetween: 2 -3 & 4
# {
# 'input' => '2',
# 'name' => 'xbetween: 2 -3 & 2 -> fail',
# 'schema' => [
# 'int',
# 'xbetween',
# [
# -3,
# '2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:int) xbetween: 2 -3 & 2 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 121 - (tags=clause:xbetween, type, type:int) xbetween: 2 -3 & 2 -> fail
# {
# 'input' => '2',
# 'name' => 'xbetween: 2 2 & 2 -> fail',
# 'schema' => [
# 'int',
# 'xbetween',
# [
# '2',
# '2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:int) xbetween: 2 2 & 2 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 122 - (tags=clause:xbetween, type, type:int) xbetween: 2 2 & 2 -> fail
# {
# 'input' => -3,
# 'name' => 'xbetween: -3 2 & 4 -> fail',
# 'schema' => [
# 'int',
# 'xbetween',
# [
# '2',
# '4'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:int) xbetween: -3 2 & 4 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 123 - (tags=clause:xbetween, type, type:int) xbetween: -3 2 & 4 -> fail
# {
# 'input' => -3,
# 'name' => '!between (nok)',
# 'schema' => [
# 'int',
# '!between',
# [
# -3,
# -3
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:not, opshortcut, type, type:int) !between (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 124 - (tags=clause:between, op, op:not, opshortcut, type, type:int) !between (nok)
# {
# 'input' => -3,
# 'name' => '!between (ok)',
# 'schema' => [
# 'int',
# '!between',
# [
# '2',
# '2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:not, opshortcut, type, type:int) !between (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 125 - (tags=clause:between, op, op:not, opshortcut, type, type:int) !between (ok)
# {
# 'input' => -3,
# 'name' => 'between.op=not (nok)',
# 'schema' => [
# 'int',
# 'between',
# [
# -3,
# -3
# ],
# 'between.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:not, type, type:int) between.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 126 - (tags=clause:between, op, op:not, type, type:int) between.op=not (nok)
# {
# 'input' => -3,
# 'name' => 'between.op=not (ok)',
# 'schema' => [
# 'int',
# 'between',
# [
# '2',
# '2'
# ],
# 'between.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:not, type, type:int) between.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 127 - (tags=clause:between, op, op:not, type, type:int) between.op=not (ok)
# {
# 'input' => -3,
# 'name' => 'between& (no items)',
# 'schema' => [
# 'int',
# 'between&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:int) between& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 128 - (tags=clause:between, op, op:and, opshortcut, type, type:int) between& (no items)
# {
# 'input' => -3,
# 'name' => 'between& (ok)',
# 'schema' => [
# 'int',
# 'between&',
# [
# [
# -3,
# -3
# ],
# [
# -3,
# -3
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:int) between& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 129 - (tags=clause:between, op, op:and, opshortcut, type, type:int) between& (ok)
# {
# 'errors' => 1,
# 'input' => -3,
# 'name' => 'between& (nok + ok)',
# 'schema' => [
# 'int',
# 'between&',
# [
# [
# '2',
# '2'
# ],
# [
# -3,
# -3
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:int) between& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 130 - (tags=clause:between, op, op:and, opshortcut, type, type:int) between& (nok + ok)
# {
# 'errors' => 1,
# 'input' => -3,
# 'name' => 'between& (ok + nok)',
# 'schema' => [
# 'int',
# 'between&',
# [
# [
# -3,
# -3
# ],
# [
# '2',
# '2'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:int) between& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 131 - (tags=clause:between, op, op:and, opshortcut, type, type:int) between& (ok + nok)
# {
# 'errors' => 1,
# 'input' => -3,
# 'name' => 'between& (nok + nok)',
# 'schema' => [
# 'int',
# 'between&',
# [
# [
# '2',
# '2'
# ],
# [
# '2',
# '2'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:int) between& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 132 - (tags=clause:between, op, op:and, opshortcut, type, type:int) between& (nok + nok)
# {
# 'input' => -3,
# 'name' => 'between.op=and (no items)',
# 'schema' => [
# 'int',
# 'between',
# [],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:int) between.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 133 - (tags=type, type:int) between.op=and (no items)
# {
# 'input' => -3,
# 'name' => 'between.op=and (ok)',
# 'schema' => [
# 'int',
# 'between',
# [
# [
# -3,
# -3
# ],
# [
# -3,
# -3
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, type, type:int) between.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 134 - (tags=clause:between, op, op:and, type, type:int) between.op=and (ok)
# {
# 'errors' => 1,
# 'input' => -3,
# 'name' => 'between.op=and (nok + ok)',
# 'schema' => [
# 'int',
# 'between',
# [
# [
# '2',
# '2'
# ],
# [
# -3,
# -3
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:int) between.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 135 - (tags=clause:between, op, op:and, type, type:int) between.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => -3,
# 'name' => 'between.op=and (ok + nok)',
# 'schema' => [
# 'int',
# 'between',
# [
# [
# -3,
# -3
# ],
# [
# '2',
# '2'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:int) between.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 136 - (tags=clause:between, op, op:and, type, type:int) between.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => -3,
# 'name' => 'between.op=and (nok + nok)',
# 'schema' => [
# 'int',
# 'between',
# [
# [
# '2',
# '2'
# ],
# [
# '2',
# '2'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:int) between.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 137 - (tags=clause:between, op, op:and, type, type:int) between.op=and (nok + nok)
# {
# 'input' => -3,
# 'name' => 'between| (no items)',
# 'schema' => [
# 'int',
# 'between|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:int) between| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 138 - (tags=clause:between, op, op:or, opshortcut, type, type:int) between| (no items)
# {
# 'input' => -3,
# 'name' => 'between| (ok)',
# 'schema' => [
# 'int',
# 'between|',
# [
# [
# -3,
# -3
# ],
# [
# -3,
# -3
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:int) between| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 139 - (tags=clause:between, op, op:or, opshortcut, type, type:int) between| (ok)
# {
# 'input' => -3,
# 'name' => 'between| (nok + ok)',
# 'schema' => [
# 'int',
# 'between|',
# [
# [
# '2',
# '2'
# ],
# [
# -3,
# -3
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:int) between| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 140 - (tags=clause:between, op, op:or, opshortcut, type, type:int) between| (nok + ok)
# {
# 'input' => -3,
# 'name' => 'between| (ok + nok)',
# 'schema' => [
# 'int',
# 'between|',
# [
# [
# -3,
# -3
# ],
# [
# '2',
# '2'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:int) between| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 141 - (tags=clause:between, op, op:or, opshortcut, type, type:int) between| (ok + nok)
# {
# 'errors' => 1,
# 'input' => -3,
# 'name' => 'between| (nok + nok)',
# 'schema' => [
# 'int',
# 'between|',
# [
# [
# '2',
# '2'
# ],
# [
# '2',
# '2'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:int) between| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 142 - (tags=clause:between, op, op:or, opshortcut, type, type:int) between| (nok + nok)
# {
# 'input' => -3,
# 'name' => 'between.op=or (no items)',
# 'schema' => [
# 'int',
# 'between',
# [],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:int) between.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 143 - (tags=clause:between, op, op:or, type, type:int) between.op=or (no items)
# {
# 'input' => -3,
# 'name' => 'between.op=or (ok)',
# 'schema' => [
# 'int',
# 'between',
# [
# [
# -3,
# -3
# ],
# [
# -3,
# -3
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:int) between.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 144 - (tags=clause:between, op, op:or, type, type:int) between.op=or (ok)
# {
# 'input' => -3,
# 'name' => 'between.op=or (nok + ok)',
# 'schema' => [
# 'int',
# 'between',
# [
# [
# '2',
# '2'
# ],
# [
# -3,
# -3
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:int) between.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 145 - (tags=clause:between, op, op:or, type, type:int) between.op=or (nok + ok)
# {
# 'input' => -3,
# 'name' => 'between.op=or (ok + nok)',
# 'schema' => [
# 'int',
# 'between',
# [
# [
# -3,
# -3
# ],
# [
# '2',
# '2'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:int) between.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 146 - (tags=clause:between, op, op:or, type, type:int) between.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => -3,
# 'name' => 'between.op=or (nok + nok)',
# 'schema' => [
# 'int',
# 'between',
# [
# [
# '2',
# '2'
# ],
# [
# '2',
# '2'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:or, type, type:int) between.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 147 - (tags=clause:between, op, op:or, type, type:int) between.op=or (nok + nok)
# {
# 'input' => -3,
# 'name' => 'between.op=none (empty items)',
# 'schema' => [
# 'int',
# 'between',
# [],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:none, type, type:int) between.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 148 - (tags=clause:between, op, op:none, type, type:int) between.op=none (empty items)
# {
# 'input' => -3,
# 'name' => 'between.op=none (nok + nok)',
# 'schema' => [
# 'int',
# 'between',
# [
# [
# '2',
# '2'
# ],
# [
# '2',
# '2'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:none, type, type:int) between.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 149 - (tags=clause:between, op, op:none, type, type:int) between.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => -3,
# 'name' => 'between.op=none (nok + ok)',
# 'schema' => [
# 'int',
# 'between',
# [
# [
# '2',
# '2'
# ],
# [
# -3,
# -3
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:int) between.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 150 - (tags=clause:between, op, op:none, type, type:int) between.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => -3,
# 'name' => 'between.op=none (ok + nok)',
# 'schema' => [
# 'int',
# 'between',
# [
# [
# -3,
# -3
# ],
# [
# '2',
# '2'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:int) between.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 151 - (tags=clause:between, op, op:none, type, type:int) between.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => -3,
# 'name' => 'between.op=none (ok + ok)',
# 'schema' => [
# 'int',
# 'between',
# [
# [
# -3,
# -3
# ],
# [
# -3,
# -3
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:int) between.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 152 - (tags=clause:between, op, op:none, type, type:int) between.op=none (ok + ok)
# {
# 'input' => 10,
# 'name' => 'mod: (nok)',
# 'schema' => [
# 'int',
# 'mod',
# [
# 3,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:mod'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:mod, type, type:int) mod: (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 153 - (tags=clause:mod, type, type:int) mod: (nok)
# {
# 'input' => 11,
# 'name' => 'mod: (ok)',
# 'schema' => [
# 'int',
# 'mod',
# [
# 3,
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:mod'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:mod, type, type:int) mod: (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 154 - (tags=clause:mod, type, type:int) mod: (ok)
# {
# 'input' => 7,
# 'name' => 'div_by: (nok)',
# 'schema' => [
# 'int',
# 'div_by',
# 3
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:div_by'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:div_by, type, type:int) div_by: (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 155 - (tags=clause:div_by, type, type:int) div_by: (nok)
# {
# 'input' => 6,
# 'name' => 'div_by: (ok)',
# 'schema' => [
# 'int',
# 'div_by',
# 3
# ],
# 'tags' => [
# 'type',
# 'type:int',
# 'clause:div_by'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:div_by, type, type:int) div_by: (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 156 - (tags=clause:div_by, type, type:int) div_by: (ok)
ok 157
1..157
ok 11 - 10-type-int.json
# Subtest: 10-type-num.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => '-1.1',
# 'name' => 'type check: must accept -1.1',
# 'schema' => 'num',
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:num) type check: must accept -1.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=type, type:num) type check: must accept -1.1
# {
# 'input' => -1,
# 'name' => 'type check: must accept -1',
# 'schema' => 'num',
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:num) type check: must accept -1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=type, type:num) type check: must accept -1
# {
# 'input' => 0,
# 'name' => 'type check: must accept 0',
# 'schema' => 'num',
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:num) type check: must accept 0
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 3 - (tags=type, type:num) type check: must accept 0
# {
# 'input' => 1,
# 'name' => 'type check: must accept 1',
# 'schema' => 'num',
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:num) type check: must accept 1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 4 - (tags=type, type:num) type check: must accept 1
# {
# 'input' => '1.1',
# 'name' => 'type check: must accept 1.1',
# 'schema' => 'num',
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:num) type check: must accept 1.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 5 - (tags=type, type:num) type check: must accept 1.1
# {
# 'input' => 'a',
# 'name' => 'type check: must reject a',
# 'schema' => 'num',
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:num) type check: must reject a
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 6 - (tags=type, type:num) type check: must reject a
# {
# 'input' => [],
# 'name' => 'type check: must reject []',
# 'schema' => 'num',
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:num) type check: must reject []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 7 - (tags=type, type:num) type check: must reject []
# {
# 'input' => {},
# 'name' => 'type check: must reject {}',
# 'schema' => 'num',
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:num) type check: must reject {}
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 8 - (tags=type, type:num) type check: must reject {}
# {
# 'input' => undef,
# 'name' => 'must accept undefined value',
# 'schema' => 'num',
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:num) must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 9 - (tags=type, type:num) must accept undefined value
# {
# 'input' => undef,
# 'name' => 'defhash_v',
# 'schema' => [
# 'num',
# 'defhash_v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:defhash_v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:defhash_v, type, type:num) defhash_v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 10 - (tags=clause:defhash_v, type, type:num) defhash_v
# {
# 'input' => undef,
# 'name' => 'v',
# 'schema' => [
# 'num',
# 'v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:v, type, type:num) v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 11 - (tags=clause:v, type, type:num) v
# {
# 'input' => undef,
# 'name' => 'c',
# 'schema' => [
# 'num',
# 'c.foo.bar',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:c'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:c, type, type:num) c
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 12 - (tags=clause:c, type, type:num) c
# {
# 'input' => undef,
# 'name' => 'default_lang',
# 'schema' => [
# 'num',
# 'default_lang',
# 'id_ID'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:default_lang'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default_lang, type, type:num) default_lang
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 13 - (tags=clause:default_lang, type, type:num) default_lang
# {
# 'input' => undef,
# 'name' => 'name',
# 'schema' => [
# 'num',
# 'name',
# 'some name'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:name'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:name, type, type:num) name
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 14 - (tags=clause:name, type, type:num) name
# {
# 'input' => undef,
# 'name' => 'summary',
# 'schema' => [
# 'num',
# 'summary',
# 'some summary'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:summary'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:summary, type, type:num) summary
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 15 - (tags=clause:summary, type, type:num) summary
# {
# 'input' => undef,
# 'name' => 'description',
# 'schema' => [
# 'num',
# 'description',
# 'some description and `markdown`'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:description'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:description, type, type:num) description
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 16 - (tags=clause:description, type, type:num) description
# {
# 'input' => undef,
# 'name' => 'tags',
# 'schema' => [
# 'num',
# 'tags',
# [
# 'some',
# 'tags'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:tags'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:tags, type, type:num) tags
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 17 - (tags=clause:tags, type, type:num) tags
# {
# 'input' => undef,
# 'name' => 'req=0 must accept undefined value',
# 'schema' => [
# 'num',
# 'req',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:req'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req, type, type:num) req=0 must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 18 - (tags=clause:req, type, type:num) req=0 must accept undefined value
# {
# 'input' => undef,
# 'name' => 'req=1 must reject undefined value',
# 'schema' => [
# 'num',
# 'req',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:req'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:req, type, type:num) req=1 must reject undefined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 19 - (tags=clause:req, type, type:num) req=1 must reject undefined value
# {
# 'input' => '1.1',
# 'name' => 'forbidden=0 must accept defined value',
# 'schema' => [
# 'num',
# 'forbidden',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:forbidden'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden, type, type:num) forbidden=0 must accept defined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 20 - (tags=clause:forbidden, type, type:num) forbidden=0 must accept defined value
# {
# 'input' => '1.1',
# 'name' => 'forbidden=1 must reject defined value',
# 'schema' => [
# 'num',
# 'forbidden',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:forbidden'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:forbidden, type, type:num) forbidden=1 must reject defined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 21 - (tags=clause:forbidden, type, type:num) forbidden=1 must reject defined value
# {
# 'input' => undef,
# 'name' => 'default: must accept valid default 1.1',
# 'schema' => [
# 'num*',
# 'default',
# '1.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:default'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default, type, type:num) default: must accept valid default 1.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 22 - (tags=clause:default, type, type:num) default: must accept valid default 1.1
# {
# 'input' => undef,
# 'name' => 'default: must reject invalid default []',
# 'schema' => [
# 'num*',
# 'default',
# []
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:default'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:default, type, type:num) default: must reject invalid default []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 23 - (tags=clause:default, type, type:num) default: must reject invalid default []
# {
# 'dies' => 1,
# 'input' => '1.1',
# 'name' => 'clause (dies, unknown clause)',
# 'schema' => [
# 'num*',
# 'clause',
# [
# 'foo',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:clause'
# ]
# }
# Subtest: (tags=clause:clause, type, type:num) clause (dies, unknown clause)
ok 1 - compile error
1..1
ok 24 - (tags=clause:clause, type, type:num) clause (dies, unknown clause)
# {
# 'input' => '1.1',
# 'name' => 'clause (ok)',
# 'schema' => [
# 'num*',
# 'clause',
# [
# 'min',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:clause'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clause, type, type:num) clause (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 25 - (tags=clause:clause, type, type:num) clause (ok)
# {
# 'input' => '1.1',
# 'name' => 'clause (ok) + clause nok = nok',
# 'schema' => [
# 'num*',
# 'clause',
# [
# 'min',
# 1
# ],
# 'max',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:num) clause (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 26 - (tags=clause:clause, type, type:num) clause (ok) + clause nok = nok
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'clause (nok)',
# 'schema' => [
# 'num*',
# 'clause',
# [
# 'min',
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:num) clause (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 27 - (tags=clause:clause, type, type:num) clause (nok)
# {
# 'dies' => 1,
# 'input' => '1.1',
# 'name' => 'clset (dies, unknown clause)',
# 'schema' => [
# 'num*',
# 'clset',
# {
# 'foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:num) clset (dies, unknown clause)
ok 1 - compile error
1..1
ok 28 - (tags=clause:clset, type, type:num) clset (dies, unknown clause)
# {
# 'dies' => 1,
# 'input' => '1.1',
# 'name' => 'clset (dies, unknown attr)',
# 'schema' => [
# 'num*',
# 'clset',
# {
# 'min_len' => 1,
# 'min_len.foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:num) clset (dies, unknown attr)
ok 1 - compile error
1..1
ok 29 - (tags=clause:clset, type, type:num) clset (dies, unknown attr)
# {
# 'input' => '1.1',
# 'name' => 'clset (empty = ok)',
# 'schema' => [
# 'num*',
# 'clset',
# {}
# ],
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:num) clset (empty = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 30 - (tags=type, type:num) clset (empty = ok)
# {
# 'input' => '1.1',
# 'name' => 'clset (ignored clause/attr = ok)',
# 'schema' => [
# 'num*',
# 'clset',
# {
# '_foo' => 1,
# 'foo._bar' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:num) clset (ignored clause/attr = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 31 - (tags=clause:clset, type, type:num) clset (ignored clause/attr = ok)
# {
# 'input' => '1.1',
# 'name' => 'clset (ok + ok = ok)',
# 'schema' => [
# 'num*',
# 'clset',
# {
# 'max' => '1.1',
# 'min' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:num) clset (ok + ok = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 32 - (tags=clause:clset, type, type:num) clset (ok + ok = ok)
# {
# 'input' => '1.1',
# 'name' => 'clset (ok) + clause nok = nok',
# 'schema' => [
# 'num*',
# 'clset',
# {
# 'min' => 1
# },
# 'max',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:num) clset (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 33 - (tags=clause:clset, type, type:num) clset (ok) + clause nok = nok
# {
# 'input' => '1.1',
# 'name' => 'clset (ok + nok = nok)',
# 'schema' => [
# 'num*',
# 'clset',
# {
# 'max' => 1,
# 'min' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:num) clset (ok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 34 - (tags=clause:clset, type, type:num) clset (ok + nok = nok)
# {
# 'input' => '1.1',
# 'name' => 'clset (nok + ok = nok)',
# 'schema' => [
# 'num*',
# 'clset',
# {
# 'max' => '1.1',
# 'min' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:num) clset (nok + ok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 35 - (tags=clause:clset, type, type:num) clset (nok + ok = nok)
# {
# 'input' => '1.1',
# 'name' => 'clset (nok + nok = nok)',
# 'schema' => [
# 'num*',
# 'clset',
# {
# 'max' => 1,
# 'min' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:num) clset (nok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 36 - (tags=clause:clset, type, type:num) clset (nok + nok = nok)
# {
# 'input' => undef,
# 'name' => 'ok',
# 'schema' => [
# 'num',
# {
# 'ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:ok'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:ok, type, type:num) ok
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 37 - (tags=clause:ok, type, type:num) ok
# {
# 'input' => undef,
# 'name' => 'ok + op not (nok)',
# 'schema' => [
# 'num',
# {
# '!ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:ok',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:ok, op, op:not, type, type:num) ok + op not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 38 - (tags=clause:ok, op, op:not, type, type:num) ok + op not (nok)
# {
# 'input' => '0.1',
# 'name' => '.err_level=error (clause=min, ok)',
# 'schema' => [
# 'num',
# 'min',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:num) .err_level=error (clause=min, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 39 - (tags=attr, attr:err_level, type, type:num) .err_level=error (clause=min, ok)
# {
# 'input' => '-0.1',
# 'name' => '.err_level=error (clause=min, nok)',
# 'schema' => [
# 'num',
# 'min',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 0
# }
# Subtest: (tags=attr, attr:err_level, type, type:num) .err_level=error (clause=min, nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 40 - (tags=attr, attr:err_level, type, type:num) .err_level=error (clause=min, nok)
# {
# 'input' => '0.1',
# 'name' => '.err_level=warn (clause=min, ok)',
# 'schema' => [
# 'num',
# 'min',
# 0,
# 'min.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:num) .err_level=warn (clause=min, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 41 - (tags=attr, attr:err_level, type, type:num) .err_level=warn (clause=min, ok)
# {
# 'input' => '-0.1',
# 'name' => '.err_level=warn (clause=min, nok)',
# 'schema' => [
# 'num*',
# 'min',
# 0,
# 'min.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1,
# 'warnings' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:num) .err_level=warn (clause=min, nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 42 - (tags=attr, attr:err_level, type, type:num) .err_level=warn (clause=min, nok)
# {
# 'input' => '1.1',
# 'name' => 'is: must accept same value',
# 'schema' => [
# 'num',
# 'is',
# '1.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, type, type:num) is: must accept same value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 43 - (tags=clause:is, type, type:num) is: must accept same value
# {
# 'input' => '1.1',
# 'name' => 'is: must reject different value',
# 'schema' => [
# 'num',
# 'is',
# '1.2'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, type, type:num) is: must reject different value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 44 - (tags=clause:is, type, type:num) is: must reject different value
# {
# 'input' => '1.1',
# 'name' => '!is (nok)',
# 'schema' => [
# 'num',
# '!is',
# '1.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:num) !is (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 45 - (tags=clause:is, op, op:not, opshortcut, type, type:num) !is (nok)
# {
# 'input' => '1.1',
# 'name' => '!is (ok)',
# 'schema' => [
# 'num',
# '!is',
# '1.2'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:num) !is (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 46 - (tags=clause:is, op, op:not, opshortcut, type, type:num) !is (ok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=not (nok)',
# 'schema' => [
# 'num',
# 'is',
# '1.1',
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, type, type:num) is.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 47 - (tags=clause:is, op, op:not, type, type:num) is.op=not (nok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=not (ok)',
# 'schema' => [
# 'num',
# 'is',
# '1.2',
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, type, type:num) is.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 48 - (tags=clause:is, op, op:not, type, type:num) is.op=not (ok)
# {
# 'input' => '1.1',
# 'name' => 'is& (no items)',
# 'schema' => [
# 'num',
# 'is&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:num) is& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 49 - (tags=clause:is, op, op:and, opshortcut, type, type:num) is& (no items)
# {
# 'input' => '1.1',
# 'name' => 'is& (ok)',
# 'schema' => [
# 'num',
# 'is&',
# [
# '1.1',
# '1.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:num) is& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 50 - (tags=clause:is, op, op:and, opshortcut, type, type:num) is& (ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is& (nok + ok)',
# 'schema' => [
# 'num',
# 'is&',
# [
# '1.2',
# '1.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:num) is& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 51 - (tags=clause:is, op, op:and, opshortcut, type, type:num) is& (nok + ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is& (ok + nok)',
# 'schema' => [
# 'num',
# 'is&',
# [
# '1.1',
# '1.2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:num) is& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 52 - (tags=clause:is, op, op:and, opshortcut, type, type:num) is& (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is& (nok + nok)',
# 'schema' => [
# 'num',
# 'is&',
# [
# '1.2',
# '1.2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:num) is& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 53 - (tags=clause:is, op, op:and, opshortcut, type, type:num) is& (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=and (no items)',
# 'schema' => [
# 'num',
# 'is',
# [],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:num) is.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 54 - (tags=type, type:num) is.op=and (no items)
# {
# 'input' => '1.1',
# 'name' => 'is.op=and (ok)',
# 'schema' => [
# 'num',
# 'is',
# [
# '1.1',
# '1.1'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, type, type:num) is.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 55 - (tags=clause:is, op, op:and, type, type:num) is.op=and (ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=and (nok + ok)',
# 'schema' => [
# 'num',
# 'is',
# [
# '1.2',
# '1.1'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:num) is.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 56 - (tags=clause:is, op, op:and, type, type:num) is.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=and (ok + nok)',
# 'schema' => [
# 'num',
# 'is',
# [
# '1.1',
# '1.2'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:num) is.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 57 - (tags=clause:is, op, op:and, type, type:num) is.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=and (nok + nok)',
# 'schema' => [
# 'num',
# 'is',
# [
# '1.2',
# '1.2'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:num) is.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 58 - (tags=clause:is, op, op:and, type, type:num) is.op=and (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'is| (no items)',
# 'schema' => [
# 'num',
# 'is|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:num) is| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 59 - (tags=clause:is, op, op:or, opshortcut, type, type:num) is| (no items)
# {
# 'input' => '1.1',
# 'name' => 'is| (ok)',
# 'schema' => [
# 'num',
# 'is|',
# [
# '1.1',
# '1.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:num) is| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 60 - (tags=clause:is, op, op:or, opshortcut, type, type:num) is| (ok)
# {
# 'input' => '1.1',
# 'name' => 'is| (nok + ok)',
# 'schema' => [
# 'num',
# 'is|',
# [
# '1.2',
# '1.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:num) is| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 61 - (tags=clause:is, op, op:or, opshortcut, type, type:num) is| (nok + ok)
# {
# 'input' => '1.1',
# 'name' => 'is| (ok + nok)',
# 'schema' => [
# 'num',
# 'is|',
# [
# '1.1',
# '1.2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:num) is| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 62 - (tags=clause:is, op, op:or, opshortcut, type, type:num) is| (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is| (nok + nok)',
# 'schema' => [
# 'num',
# 'is|',
# [
# '1.2',
# '1.2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:num) is| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 63 - (tags=clause:is, op, op:or, opshortcut, type, type:num) is| (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=or (no items)',
# 'schema' => [
# 'num',
# 'is',
# [],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:num) is.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 64 - (tags=clause:is, op, op:or, type, type:num) is.op=or (no items)
# {
# 'input' => '1.1',
# 'name' => 'is.op=or (ok)',
# 'schema' => [
# 'num',
# 'is',
# [
# '1.1',
# '1.1'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:num) is.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 65 - (tags=clause:is, op, op:or, type, type:num) is.op=or (ok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=or (nok + ok)',
# 'schema' => [
# 'num',
# 'is',
# [
# '1.2',
# '1.1'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:num) is.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 66 - (tags=clause:is, op, op:or, type, type:num) is.op=or (nok + ok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=or (ok + nok)',
# 'schema' => [
# 'num',
# 'is',
# [
# '1.1',
# '1.2'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:num) is.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 67 - (tags=clause:is, op, op:or, type, type:num) is.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=or (nok + nok)',
# 'schema' => [
# 'num',
# 'is',
# [
# '1.2',
# '1.2'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, type, type:num) is.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 68 - (tags=clause:is, op, op:or, type, type:num) is.op=or (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'is.op=none (empty items)',
# 'schema' => [
# 'num',
# 'is',
# [],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:num) is.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 69 - (tags=clause:is, op, op:none, type, type:num) is.op=none (empty items)
# {
# 'input' => '1.1',
# 'name' => 'is.op=none (nok + nok)',
# 'schema' => [
# 'num',
# 'is',
# [
# '1.2',
# '1.2'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:num) is.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 70 - (tags=clause:is, op, op:none, type, type:num) is.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=none (nok + ok)',
# 'schema' => [
# 'num',
# 'is',
# [
# '1.2',
# '1.1'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:num) is.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 71 - (tags=clause:is, op, op:none, type, type:num) is.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=none (ok + nok)',
# 'schema' => [
# 'num',
# 'is',
# [
# '1.1',
# '1.2'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:num) is.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 72 - (tags=clause:is, op, op:none, type, type:num) is.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'is.op=none (ok + ok)',
# 'schema' => [
# 'num',
# 'is',
# [
# '1.1',
# '1.1'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:num) is.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 73 - (tags=clause:is, op, op:none, type, type:num) is.op=none (ok + ok)
# {
# 'input' => '1.1',
# 'name' => 'in: must accept valid choices',
# 'schema' => [
# 'num',
# 'in',
# [
# '1.1',
# '1.2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, type, type:num) in: must accept valid choices
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 74 - (tags=clause:in, type, type:num) in: must accept valid choices
# {
# 'input' => '1.1',
# 'name' => 'in: must reject empty choices',
# 'schema' => [
# 'num',
# 'in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, type, type:num) in: must reject empty choices
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 75 - (tags=clause:in, type, type:num) in: must reject empty choices
# {
# 'input' => '1.1',
# 'name' => '!in (nok)',
# 'schema' => [
# 'num',
# '!in',
# [
# '1.1',
# '1.2'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:num) !in (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 76 - (tags=clause:in, op, op:not, opshortcut, type, type:num) !in (nok)
# {
# 'input' => '1.1',
# 'name' => '!in (ok)',
# 'schema' => [
# 'num',
# '!in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:num) !in (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 77 - (tags=clause:in, op, op:not, opshortcut, type, type:num) !in (ok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=not (nok)',
# 'schema' => [
# 'num',
# 'in',
# [
# '1.1',
# '1.2'
# ],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, type, type:num) in.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 78 - (tags=clause:in, op, op:not, type, type:num) in.op=not (nok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=not (ok)',
# 'schema' => [
# 'num',
# 'in',
# [],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, type, type:num) in.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 79 - (tags=clause:in, op, op:not, type, type:num) in.op=not (ok)
# {
# 'input' => '1.1',
# 'name' => 'in& (no items)',
# 'schema' => [
# 'num',
# 'in&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:num) in& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 80 - (tags=clause:in, op, op:and, opshortcut, type, type:num) in& (no items)
# {
# 'input' => '1.1',
# 'name' => 'in& (ok)',
# 'schema' => [
# 'num',
# 'in&',
# [
# [
# '1.1',
# '1.2'
# ],
# [
# '1.1',
# '1.2'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:num) in& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 81 - (tags=clause:in, op, op:and, opshortcut, type, type:num) in& (ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in& (nok + ok)',
# 'schema' => [
# 'num',
# 'in&',
# [
# [],
# [
# '1.1',
# '1.2'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:num) in& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 82 - (tags=clause:in, op, op:and, opshortcut, type, type:num) in& (nok + ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in& (ok + nok)',
# 'schema' => [
# 'num',
# 'in&',
# [
# [
# '1.1',
# '1.2'
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:num) in& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 83 - (tags=clause:in, op, op:and, opshortcut, type, type:num) in& (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in& (nok + nok)',
# 'schema' => [
# 'num',
# 'in&',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:num) in& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 84 - (tags=clause:in, op, op:and, opshortcut, type, type:num) in& (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=and (no items)',
# 'schema' => [
# 'num',
# 'in',
# [],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:num) in.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 85 - (tags=type, type:num) in.op=and (no items)
# {
# 'input' => '1.1',
# 'name' => 'in.op=and (ok)',
# 'schema' => [
# 'num',
# 'in',
# [
# [
# '1.1',
# '1.2'
# ],
# [
# '1.1',
# '1.2'
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, type, type:num) in.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 86 - (tags=clause:in, op, op:and, type, type:num) in.op=and (ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=and (nok + ok)',
# 'schema' => [
# 'num',
# 'in',
# [
# [],
# [
# '1.1',
# '1.2'
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:num) in.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 87 - (tags=clause:in, op, op:and, type, type:num) in.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=and (ok + nok)',
# 'schema' => [
# 'num',
# 'in',
# [
# [
# '1.1',
# '1.2'
# ],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:num) in.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 88 - (tags=clause:in, op, op:and, type, type:num) in.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=and (nok + nok)',
# 'schema' => [
# 'num',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:num) in.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 89 - (tags=clause:in, op, op:and, type, type:num) in.op=and (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'in| (no items)',
# 'schema' => [
# 'num',
# 'in|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:num) in| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 90 - (tags=clause:in, op, op:or, opshortcut, type, type:num) in| (no items)
# {
# 'input' => '1.1',
# 'name' => 'in| (ok)',
# 'schema' => [
# 'num',
# 'in|',
# [
# [
# '1.1',
# '1.2'
# ],
# [
# '1.1',
# '1.2'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:num) in| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 91 - (tags=clause:in, op, op:or, opshortcut, type, type:num) in| (ok)
# {
# 'input' => '1.1',
# 'name' => 'in| (nok + ok)',
# 'schema' => [
# 'num',
# 'in|',
# [
# [],
# [
# '1.1',
# '1.2'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:num) in| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 92 - (tags=clause:in, op, op:or, opshortcut, type, type:num) in| (nok + ok)
# {
# 'input' => '1.1',
# 'name' => 'in| (ok + nok)',
# 'schema' => [
# 'num',
# 'in|',
# [
# [
# '1.1',
# '1.2'
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:num) in| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 93 - (tags=clause:in, op, op:or, opshortcut, type, type:num) in| (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in| (nok + nok)',
# 'schema' => [
# 'num',
# 'in|',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:num) in| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 94 - (tags=clause:in, op, op:or, opshortcut, type, type:num) in| (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=or (no items)',
# 'schema' => [
# 'num',
# 'in',
# [],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:num) in.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 95 - (tags=clause:in, op, op:or, type, type:num) in.op=or (no items)
# {
# 'input' => '1.1',
# 'name' => 'in.op=or (ok)',
# 'schema' => [
# 'num',
# 'in',
# [
# [
# '1.1',
# '1.2'
# ],
# [
# '1.1',
# '1.2'
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:num) in.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 96 - (tags=clause:in, op, op:or, type, type:num) in.op=or (ok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=or (nok + ok)',
# 'schema' => [
# 'num',
# 'in',
# [
# [],
# [
# '1.1',
# '1.2'
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:num) in.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 97 - (tags=clause:in, op, op:or, type, type:num) in.op=or (nok + ok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=or (ok + nok)',
# 'schema' => [
# 'num',
# 'in',
# [
# [
# '1.1',
# '1.2'
# ],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:num) in.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 98 - (tags=clause:in, op, op:or, type, type:num) in.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=or (nok + nok)',
# 'schema' => [
# 'num',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, type, type:num) in.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 99 - (tags=clause:in, op, op:or, type, type:num) in.op=or (nok + nok)
# {
# 'input' => '1.1',
# 'name' => 'in.op=none (empty items)',
# 'schema' => [
# 'num',
# 'in',
# [],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:num) in.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 100 - (tags=clause:in, op, op:none, type, type:num) in.op=none (empty items)
# {
# 'input' => '1.1',
# 'name' => 'in.op=none (nok + nok)',
# 'schema' => [
# 'num',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:num) in.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 101 - (tags=clause:in, op, op:none, type, type:num) in.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=none (nok + ok)',
# 'schema' => [
# 'num',
# 'in',
# [
# [],
# [
# '1.1',
# '1.2'
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:num) in.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 102 - (tags=clause:in, op, op:none, type, type:num) in.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=none (ok + nok)',
# 'schema' => [
# 'num',
# 'in',
# [
# [
# '1.1',
# '1.2'
# ],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:num) in.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 103 - (tags=clause:in, op, op:none, type, type:num) in.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => '1.1',
# 'name' => 'in.op=none (ok + ok)',
# 'schema' => [
# 'num',
# 'in',
# [
# [
# '1.1',
# '1.2'
# ],
# [
# '1.1',
# '1.2'
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:num) in.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 104 - (tags=clause:in, op, op:none, type, type:num) in.op=none (ok + ok)
# {
# 'input' => '2.1',
# 'name' => 'min: 2.1 -3.1',
# 'schema' => [
# 'num',
# 'min',
# '-3.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:num) min: 2.1 -3.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 105 - (tags=clause:min, type, type:num) min: 2.1 -3.1
# {
# 'input' => '2.1',
# 'name' => 'min: 2.1 2.1',
# 'schema' => [
# 'num',
# 'min',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:num) min: 2.1 2.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 106 - (tags=clause:min, type, type:num) min: 2.1 2.1
# {
# 'input' => '-3.1',
# 'name' => 'min: -3.1 2.1 -> fail',
# 'schema' => [
# 'num',
# 'min',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:min'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:min, type, type:num) min: -3.1 2.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 107 - (tags=clause:min, type, type:num) min: -3.1 2.1 -> fail
# {
# 'input' => '2.1',
# 'name' => 'xmin: 2.1 -3.1',
# 'schema' => [
# 'num',
# 'xmin',
# '-3.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:xmin'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmin, type, type:num) xmin: 2.1 -3.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 108 - (tags=clause:xmin, type, type:num) xmin: 2.1 -3.1
# {
# 'input' => '2.1',
# 'name' => 'xmin: 2.1 2.1 -> fail',
# 'schema' => [
# 'num',
# 'xmin',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:num) xmin: 2.1 2.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 109 - (tags=clause:xmin, type, type:num) xmin: 2.1 2.1 -> fail
# {
# 'input' => '-3.1',
# 'name' => 'xmin: -3.1 2.1 -> fail',
# 'schema' => [
# 'num',
# 'xmin',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:num) xmin: -3.1 2.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 110 - (tags=clause:xmin, type, type:num) xmin: -3.1 2.1 -> fail
# {
# 'input' => '2.1',
# 'name' => 'max: 2.1 -3.1 -> fail',
# 'schema' => [
# 'num',
# 'max',
# '-3.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:max'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:max, type, type:num) max: 2.1 -3.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 111 - (tags=clause:max, type, type:num) max: 2.1 -3.1 -> fail
# {
# 'input' => '2.1',
# 'name' => 'max: 2.1 2.1',
# 'schema' => [
# 'num',
# 'max',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:num) max: 2.1 2.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 112 - (tags=clause:max, type, type:num) max: 2.1 2.1
# {
# 'input' => '-3.1',
# 'name' => 'max: -3.1 2.1',
# 'schema' => [
# 'num',
# 'max',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:num) max: -3.1 2.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 113 - (tags=clause:max, type, type:num) max: -3.1 2.1
# {
# 'input' => '2.1',
# 'name' => 'xmax: 2.1 -3.1 -> fail',
# 'schema' => [
# 'num',
# 'xmax',
# '-3.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:num) xmax: 2.1 -3.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 114 - (tags=clause:xmax, type, type:num) xmax: 2.1 -3.1 -> fail
# {
# 'input' => '2.1',
# 'name' => 'xmax: 2.1 2.1 -> fail',
# 'schema' => [
# 'num',
# 'xmax',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:num) xmax: 2.1 2.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 115 - (tags=clause:xmax, type, type:num) xmax: 2.1 2.1 -> fail
# {
# 'input' => '-3.1',
# 'name' => 'xmax: -3.1 2.1',
# 'schema' => [
# 'num',
# 'xmax',
# '2.1'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:xmax'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmax, type, type:num) xmax: -3.1 2.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 116 - (tags=clause:xmax, type, type:num) xmax: -3.1 2.1
# {
# 'input' => '2.1',
# 'name' => 'between: 2.1 -3.1 & 4.1',
# 'schema' => [
# 'num',
# 'between',
# [
# '-3.1',
# '4.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:num) between: 2.1 -3.1 & 4.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 117 - (tags=clause:between, type, type:num) between: 2.1 -3.1 & 4.1
# {
# 'input' => '2.1',
# 'name' => 'between: 2.1 -3.1 & 2.1',
# 'schema' => [
# 'num',
# 'between',
# [
# '-3.1',
# '2.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:num) between: 2.1 -3.1 & 2.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 118 - (tags=clause:between, type, type:num) between: 2.1 -3.1 & 2.1
# {
# 'input' => '2.1',
# 'name' => 'between: 2.1 2.1 & 2.1',
# 'schema' => [
# 'num',
# 'between',
# [
# '2.1',
# '2.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:num) between: 2.1 2.1 & 2.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 119 - (tags=clause:between, type, type:num) between: 2.1 2.1 & 2.1
# {
# 'input' => '-3.1',
# 'name' => 'between: -3.1 2.1 & 4.1 -> fail',
# 'schema' => [
# 'num',
# 'between',
# [
# '2.1',
# '4.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, type, type:num) between: -3.1 2.1 & 4.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 120 - (tags=clause:between, type, type:num) between: -3.1 2.1 & 4.1 -> fail
# {
# 'input' => '2.1',
# 'name' => 'xbetween: 2.1 -3.1 & 4.1',
# 'schema' => [
# 'num',
# 'xbetween',
# [
# '-3.1',
# '4.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:xbetween'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xbetween, type, type:num) xbetween: 2.1 -3.1 & 4.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 121 - (tags=clause:xbetween, type, type:num) xbetween: 2.1 -3.1 & 4.1
# {
# 'input' => '2.1',
# 'name' => 'xbetween: 2.1 -3.1 & 2.1 -> fail',
# 'schema' => [
# 'num',
# 'xbetween',
# [
# '-3.1',
# '2.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:num) xbetween: 2.1 -3.1 & 2.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 122 - (tags=clause:xbetween, type, type:num) xbetween: 2.1 -3.1 & 2.1 -> fail
# {
# 'input' => '2.1',
# 'name' => 'xbetween: 2.1 2.1 & 2.1 -> fail',
# 'schema' => [
# 'num',
# 'xbetween',
# [
# '2.1',
# '2.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:num) xbetween: 2.1 2.1 & 2.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 123 - (tags=clause:xbetween, type, type:num) xbetween: 2.1 2.1 & 2.1 -> fail
# {
# 'input' => '-3.1',
# 'name' => 'xbetween: -3.1 2.1 & 4.1 -> fail',
# 'schema' => [
# 'num',
# 'xbetween',
# [
# '2.1',
# '4.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:num) xbetween: -3.1 2.1 & 4.1 -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 124 - (tags=clause:xbetween, type, type:num) xbetween: -3.1 2.1 & 4.1 -> fail
# {
# 'input' => '-3.1',
# 'name' => '!between (nok)',
# 'schema' => [
# 'num',
# '!between',
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:not, opshortcut, type, type:num) !between (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 125 - (tags=clause:between, op, op:not, opshortcut, type, type:num) !between (nok)
# {
# 'input' => '-3.1',
# 'name' => '!between (ok)',
# 'schema' => [
# 'num',
# '!between',
# [
# '2.1',
# '2.1'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:not, opshortcut, type, type:num) !between (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 126 - (tags=clause:between, op, op:not, opshortcut, type, type:num) !between (ok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=not (nok)',
# 'schema' => [
# 'num',
# 'between',
# [
# '-3.1',
# '-3.1'
# ],
# 'between.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:not, type, type:num) between.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 127 - (tags=clause:between, op, op:not, type, type:num) between.op=not (nok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=not (ok)',
# 'schema' => [
# 'num',
# 'between',
# [
# '2.1',
# '2.1'
# ],
# 'between.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:not, type, type:num) between.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 128 - (tags=clause:between, op, op:not, type, type:num) between.op=not (ok)
# {
# 'input' => '-3.1',
# 'name' => 'between& (no items)',
# 'schema' => [
# 'num',
# 'between&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:num) between& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 129 - (tags=clause:between, op, op:and, opshortcut, type, type:num) between& (no items)
# {
# 'input' => '-3.1',
# 'name' => 'between& (ok)',
# 'schema' => [
# 'num',
# 'between&',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:num) between& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 130 - (tags=clause:between, op, op:and, opshortcut, type, type:num) between& (ok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between& (nok + ok)',
# 'schema' => [
# 'num',
# 'between&',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:num) between& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 131 - (tags=clause:between, op, op:and, opshortcut, type, type:num) between& (nok + ok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between& (ok + nok)',
# 'schema' => [
# 'num',
# 'between&',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:num) between& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 132 - (tags=clause:between, op, op:and, opshortcut, type, type:num) between& (ok + nok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between& (nok + nok)',
# 'schema' => [
# 'num',
# 'between&',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:num) between& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 133 - (tags=clause:between, op, op:and, opshortcut, type, type:num) between& (nok + nok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=and (no items)',
# 'schema' => [
# 'num',
# 'between',
# [],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:num) between.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 134 - (tags=type, type:num) between.op=and (no items)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=and (ok)',
# 'schema' => [
# 'num',
# 'between',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, type, type:num) between.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 135 - (tags=clause:between, op, op:and, type, type:num) between.op=and (ok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=and (nok + ok)',
# 'schema' => [
# 'num',
# 'between',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:num) between.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 136 - (tags=clause:between, op, op:and, type, type:num) between.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=and (ok + nok)',
# 'schema' => [
# 'num',
# 'between',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:num) between.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 137 - (tags=clause:between, op, op:and, type, type:num) between.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=and (nok + nok)',
# 'schema' => [
# 'num',
# 'between',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:num) between.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 138 - (tags=clause:between, op, op:and, type, type:num) between.op=and (nok + nok)
# {
# 'input' => '-3.1',
# 'name' => 'between| (no items)',
# 'schema' => [
# 'num',
# 'between|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:num) between| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 139 - (tags=clause:between, op, op:or, opshortcut, type, type:num) between| (no items)
# {
# 'input' => '-3.1',
# 'name' => 'between| (ok)',
# 'schema' => [
# 'num',
# 'between|',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:num) between| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 140 - (tags=clause:between, op, op:or, opshortcut, type, type:num) between| (ok)
# {
# 'input' => '-3.1',
# 'name' => 'between| (nok + ok)',
# 'schema' => [
# 'num',
# 'between|',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:num) between| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 141 - (tags=clause:between, op, op:or, opshortcut, type, type:num) between| (nok + ok)
# {
# 'input' => '-3.1',
# 'name' => 'between| (ok + nok)',
# 'schema' => [
# 'num',
# 'between|',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:num) between| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 142 - (tags=clause:between, op, op:or, opshortcut, type, type:num) between| (ok + nok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between| (nok + nok)',
# 'schema' => [
# 'num',
# 'between|',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:num) between| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 143 - (tags=clause:between, op, op:or, opshortcut, type, type:num) between| (nok + nok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=or (no items)',
# 'schema' => [
# 'num',
# 'between',
# [],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:num) between.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 144 - (tags=clause:between, op, op:or, type, type:num) between.op=or (no items)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=or (ok)',
# 'schema' => [
# 'num',
# 'between',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:num) between.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 145 - (tags=clause:between, op, op:or, type, type:num) between.op=or (ok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=or (nok + ok)',
# 'schema' => [
# 'num',
# 'between',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:num) between.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 146 - (tags=clause:between, op, op:or, type, type:num) between.op=or (nok + ok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=or (ok + nok)',
# 'schema' => [
# 'num',
# 'between',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:num) between.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 147 - (tags=clause:between, op, op:or, type, type:num) between.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=or (nok + nok)',
# 'schema' => [
# 'num',
# 'between',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:or, type, type:num) between.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 148 - (tags=clause:between, op, op:or, type, type:num) between.op=or (nok + nok)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=none (empty items)',
# 'schema' => [
# 'num',
# 'between',
# [],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:none, type, type:num) between.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 149 - (tags=clause:between, op, op:none, type, type:num) between.op=none (empty items)
# {
# 'input' => '-3.1',
# 'name' => 'between.op=none (nok + nok)',
# 'schema' => [
# 'num',
# 'between',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:none, type, type:num) between.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 150 - (tags=clause:between, op, op:none, type, type:num) between.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=none (nok + ok)',
# 'schema' => [
# 'num',
# 'between',
# [
# [
# '2.1',
# '2.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:num) between.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 151 - (tags=clause:between, op, op:none, type, type:num) between.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=none (ok + nok)',
# 'schema' => [
# 'num',
# 'between',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '2.1',
# '2.1'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:num) between.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 152 - (tags=clause:between, op, op:none, type, type:num) between.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => '-3.1',
# 'name' => 'between.op=none (ok + ok)',
# 'schema' => [
# 'num',
# 'between',
# [
# [
# '-3.1',
# '-3.1'
# ],
# [
# '-3.1',
# '-3.1'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:num',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:num) between.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 153 - (tags=clause:between, op, op:none, type, type:num) between.op=none (ok + ok)
ok 154
1..154
ok 12 - 10-type-num.json
# Subtest: 10-type-obj.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => 1,
# 'name' => 'can (nok)',
# 'schema' => [
# 'obj',
# {
# 'can' => 'foo'
# }
# ],
# 'tags' => [
# 'type',
# 'type:obj',
# 'clause:can'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:can, type, type:obj) can (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=clause:can, type, type:obj) can (nok)
# {
# 'input' => 1,
# 'name' => 'isa (nok)',
# 'schema' => [
# 'obj',
# {
# 'isa' => 'foo'
# }
# ],
# 'tags' => [
# 'type',
# 'type:obj',
# 'clause:isa'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:isa, type, type:obj) isa (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=clause:isa, type, type:obj) isa (nok)
ok 3
1..3
ok 13 - 10-type-obj.json
# Subtest: 10-type-str.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => 0,
# 'name' => 'type check: must accept 0',
# 'schema' => 'str',
# 'tags' => [
# 'type',
# 'type:str'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:str) type check: must accept 0
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=type, type:str) type check: must accept 0
# {
# 'input' => '1.1',
# 'name' => 'type check: must accept 1.1',
# 'schema' => 'str',
# 'tags' => [
# 'type',
# 'type:str'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:str) type check: must accept 1.1
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=type, type:str) type check: must accept 1.1
# {
# 'input' => '',
# 'name' => 'type check: must accept ',
# 'schema' => 'str',
# 'tags' => [
# 'type',
# 'type:str'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:str) type check: must accept
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 3 - (tags=type, type:str) type check: must accept
# {
# 'input' => 'str
# ',
# 'name' => 'type check: must accept str
# ',
# 'schema' => 'str',
# 'tags' => [
# 'type',
# 'type:str'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:str) type check: must accept str
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 4 - (tags=type, type:str) type check: must accept str
#
# {
# 'input' => [],
# 'name' => 'type check: must reject []',
# 'schema' => 'str',
# 'tags' => [
# 'type',
# 'type:str'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:str) type check: must reject []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 5 - (tags=type, type:str) type check: must reject []
# {
# 'input' => {},
# 'name' => 'type check: must reject {}',
# 'schema' => 'str',
# 'tags' => [
# 'type',
# 'type:str'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:str) type check: must reject {}
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 6 - (tags=type, type:str) type check: must reject {}
# {
# 'input' => undef,
# 'name' => 'must accept undefined value',
# 'schema' => 'str',
# 'tags' => [
# 'type',
# 'type:str'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:str) must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 7 - (tags=type, type:str) must accept undefined value
# {
# 'input' => undef,
# 'name' => 'defhash_v',
# 'schema' => [
# 'str',
# 'defhash_v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:defhash_v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:defhash_v, type, type:str) defhash_v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 8 - (tags=clause:defhash_v, type, type:str) defhash_v
# {
# 'input' => undef,
# 'name' => 'v',
# 'schema' => [
# 'str',
# 'v',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:v'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:v, type, type:str) v
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 9 - (tags=clause:v, type, type:str) v
# {
# 'input' => undef,
# 'name' => 'c',
# 'schema' => [
# 'str',
# 'c.foo.bar',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:c'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:c, type, type:str) c
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 10 - (tags=clause:c, type, type:str) c
# {
# 'input' => undef,
# 'name' => 'default_lang',
# 'schema' => [
# 'str',
# 'default_lang',
# 'id_ID'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:default_lang'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default_lang, type, type:str) default_lang
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 11 - (tags=clause:default_lang, type, type:str) default_lang
# {
# 'input' => undef,
# 'name' => 'name',
# 'schema' => [
# 'str',
# 'name',
# 'some name'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:name'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:name, type, type:str) name
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 12 - (tags=clause:name, type, type:str) name
# {
# 'input' => undef,
# 'name' => 'summary',
# 'schema' => [
# 'str',
# 'summary',
# 'some summary'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:summary'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:summary, type, type:str) summary
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 13 - (tags=clause:summary, type, type:str) summary
# {
# 'input' => undef,
# 'name' => 'description',
# 'schema' => [
# 'str',
# 'description',
# 'some description and `markdown`'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:description'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:description, type, type:str) description
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 14 - (tags=clause:description, type, type:str) description
# {
# 'input' => undef,
# 'name' => 'tags',
# 'schema' => [
# 'str',
# 'tags',
# [
# 'some',
# 'tags'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:tags'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:tags, type, type:str) tags
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 15 - (tags=clause:tags, type, type:str) tags
# {
# 'input' => undef,
# 'name' => 'req=0 must accept undefined value',
# 'schema' => [
# 'str',
# 'req',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:req'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:req, type, type:str) req=0 must accept undefined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 16 - (tags=clause:req, type, type:str) req=0 must accept undefined value
# {
# 'input' => undef,
# 'name' => 'req=1 must reject undefined value',
# 'schema' => [
# 'str',
# 'req',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:req'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:req, type, type:str) req=1 must reject undefined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 17 - (tags=clause:req, type, type:str) req=1 must reject undefined value
# {
# 'input' => 'a',
# 'name' => 'forbidden=0 must accept defined value',
# 'schema' => [
# 'str',
# 'forbidden',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:forbidden'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:forbidden, type, type:str) forbidden=0 must accept defined value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 18 - (tags=clause:forbidden, type, type:str) forbidden=0 must accept defined value
# {
# 'input' => 'a',
# 'name' => 'forbidden=1 must reject defined value',
# 'schema' => [
# 'str',
# 'forbidden',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:forbidden'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:forbidden, type, type:str) forbidden=1 must reject defined value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 19 - (tags=clause:forbidden, type, type:str) forbidden=1 must reject defined value
# {
# 'input' => undef,
# 'name' => 'default: must accept valid default a',
# 'schema' => [
# 'str*',
# 'default',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:default'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:default, type, type:str) default: must accept valid default a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 20 - (tags=clause:default, type, type:str) default: must accept valid default a
# {
# 'input' => undef,
# 'name' => 'default: must reject invalid default []',
# 'schema' => [
# 'str*',
# 'default',
# []
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:default'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:default, type, type:str) default: must reject invalid default []
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 21 - (tags=clause:default, type, type:str) default: must reject invalid default []
# {
# 'dies' => 1,
# 'input' => 'a',
# 'name' => 'clause (dies, unknown clause)',
# 'schema' => [
# 'str*',
# 'clause',
# [
# 'foo',
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:clause'
# ]
# }
# Subtest: (tags=clause:clause, type, type:str) clause (dies, unknown clause)
ok 1 - compile error
1..1
ok 22 - (tags=clause:clause, type, type:str) clause (dies, unknown clause)
# {
# 'input' => 'a',
# 'name' => 'clause (ok)',
# 'schema' => [
# 'str*',
# 'clause',
# [
# 'match',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:clause'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clause, type, type:str) clause (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 23 - (tags=clause:clause, type, type:str) clause (ok)
# {
# 'input' => 'a',
# 'name' => 'clause (ok) + clause nok = nok',
# 'schema' => [
# 'str*',
# 'clause',
# [
# 'match',
# 'a'
# ],
# 'len',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:str) clause (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 24 - (tags=clause:clause, type, type:str) clause (ok) + clause nok = nok
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'clause (nok)',
# 'schema' => [
# 'str*',
# 'clause',
# [
# 'match',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:clause'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clause, type, type:str) clause (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 25 - (tags=clause:clause, type, type:str) clause (nok)
# {
# 'dies' => 1,
# 'input' => 'a',
# 'name' => 'clset (dies, unknown clause)',
# 'schema' => [
# 'str*',
# 'clset',
# {
# 'foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:str) clset (dies, unknown clause)
ok 1 - compile error
1..1
ok 26 - (tags=clause:clset, type, type:str) clset (dies, unknown clause)
# {
# 'dies' => 1,
# 'input' => 'a',
# 'name' => 'clset (dies, unknown attr)',
# 'schema' => [
# 'str*',
# 'clset',
# {
# 'min_len' => 1,
# 'min_len.foo' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:clset'
# ]
# }
# Subtest: (tags=clause:clset, type, type:str) clset (dies, unknown attr)
ok 1 - compile error
1..1
ok 27 - (tags=clause:clset, type, type:str) clset (dies, unknown attr)
# {
# 'input' => 'a',
# 'name' => 'clset (empty = ok)',
# 'schema' => [
# 'str*',
# 'clset',
# {}
# ],
# 'tags' => [
# 'type',
# 'type:str'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:str) clset (empty = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 28 - (tags=type, type:str) clset (empty = ok)
# {
# 'input' => 'a',
# 'name' => 'clset (ignored clause/attr = ok)',
# 'schema' => [
# 'str*',
# 'clset',
# {
# '_foo' => 1,
# 'foo._bar' => 2
# }
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:str) clset (ignored clause/attr = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 29 - (tags=clause:clset, type, type:str) clset (ignored clause/attr = ok)
# {
# 'input' => 'a',
# 'name' => 'clset (ok + ok = ok)',
# 'schema' => [
# 'str*',
# 'clset',
# {
# 'len' => 1,
# 'match' => 'a'
# }
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:clset'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:clset, type, type:str) clset (ok + ok = ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 30 - (tags=clause:clset, type, type:str) clset (ok + ok = ok)
# {
# 'input' => 'a',
# 'name' => 'clset (ok) + clause nok = nok',
# 'schema' => [
# 'str*',
# 'clset',
# {
# 'match' => 'a'
# },
# 'len',
# 2
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:str) clset (ok) + clause nok = nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 31 - (tags=clause:clset, type, type:str) clset (ok) + clause nok = nok
# {
# 'input' => 'a',
# 'name' => 'clset (ok + nok = nok)',
# 'schema' => [
# 'str*',
# 'clset',
# {
# 'len' => 2,
# 'match' => 'a'
# }
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:str) clset (ok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 32 - (tags=clause:clset, type, type:str) clset (ok + nok = nok)
# {
# 'input' => 'a',
# 'name' => 'clset (nok + ok = nok)',
# 'schema' => [
# 'str*',
# 'clset',
# {
# 'len' => 1,
# 'match' => 'b'
# }
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:str) clset (nok + ok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 33 - (tags=clause:clset, type, type:str) clset (nok + ok = nok)
# {
# 'input' => 'a',
# 'name' => 'clset (nok + nok = nok)',
# 'schema' => [
# 'str*',
# 'clset',
# {
# 'len' => 2,
# 'match' => 'b'
# }
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:clset'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:clset, type, type:str) clset (nok + nok = nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 34 - (tags=clause:clset, type, type:str) clset (nok + nok = nok)
# {
# 'input' => undef,
# 'name' => 'ok',
# 'schema' => [
# 'str',
# {
# 'ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:ok'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:ok, type, type:str) ok
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 35 - (tags=clause:ok, type, type:str) ok
# {
# 'input' => undef,
# 'name' => 'ok + op not (nok)',
# 'schema' => [
# 'str',
# {
# '!ok' => 1
# }
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:ok',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:ok, op, op:not, type, type:str) ok + op not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 36 - (tags=clause:ok, op, op:not, type, type:str) ok + op not (nok)
# {
# 'input' => 'a',
# 'name' => '.err_level=error (clause=is, ok)',
# 'schema' => [
# 'str',
# 'is',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:str) .err_level=error (clause=is, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 37 - (tags=attr, attr:err_level, type, type:str) .err_level=error (clause=is, ok)
# {
# 'input' => 'a
# ',
# 'name' => '.err_level=error (clause=is, nok)',
# 'schema' => [
# 'str',
# 'is',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 0
# }
# Subtest: (tags=attr, attr:err_level, type, type:str) .err_level=error (clause=is, nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 38 - (tags=attr, attr:err_level, type, type:str) .err_level=error (clause=is, nok)
# {
# 'input' => 'a',
# 'name' => '.err_level=warn (clause=is, ok)',
# 'schema' => [
# 'str',
# 'is',
# 'a',
# 'is.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:str) .err_level=warn (clause=is, ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 39 - (tags=attr, attr:err_level, type, type:str) .err_level=warn (clause=is, ok)
# {
# 'input' => 'a
# ',
# 'name' => '.err_level=warn (clause=is, nok)',
# 'schema' => [
# 'str*',
# 'is',
# 'a',
# 'is.err_level',
# 'warn'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'attr',
# 'attr:err_level'
# ],
# 'valid' => 1,
# 'warnings' => 1
# }
# Subtest: (tags=attr, attr:err_level, type, type:str) .err_level=warn (clause=is, nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 40 - (tags=attr, attr:err_level, type, type:str) .err_level=warn (clause=is, nok)
# {
# 'input' => 'a',
# 'name' => 'is: must accept same value',
# 'schema' => [
# 'str',
# 'is',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, type, type:str) is: must accept same value
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 41 - (tags=clause:is, type, type:str) is: must accept same value
# {
# 'input' => 'a',
# 'name' => 'is: must reject different value',
# 'schema' => [
# 'str',
# 'is',
# 'b'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, type, type:str) is: must reject different value
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 42 - (tags=clause:is, type, type:str) is: must reject different value
# {
# 'input' => 'a',
# 'name' => '!is (nok)',
# 'schema' => [
# 'str',
# '!is',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:str) !is (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 43 - (tags=clause:is, op, op:not, opshortcut, type, type:str) !is (nok)
# {
# 'input' => 'a',
# 'name' => '!is (ok)',
# 'schema' => [
# 'str',
# '!is',
# 'b'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, opshortcut, type, type:str) !is (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 44 - (tags=clause:is, op, op:not, opshortcut, type, type:str) !is (ok)
# {
# 'input' => 'a',
# 'name' => 'is.op=not (nok)',
# 'schema' => [
# 'str',
# 'is',
# 'a',
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:not, type, type:str) is.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 45 - (tags=clause:is, op, op:not, type, type:str) is.op=not (nok)
# {
# 'input' => 'a',
# 'name' => 'is.op=not (ok)',
# 'schema' => [
# 'str',
# 'is',
# 'b',
# 'is.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:not, type, type:str) is.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 46 - (tags=clause:is, op, op:not, type, type:str) is.op=not (ok)
# {
# 'input' => 'a',
# 'name' => 'is& (no items)',
# 'schema' => [
# 'str',
# 'is&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:str) is& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 47 - (tags=clause:is, op, op:and, opshortcut, type, type:str) is& (no items)
# {
# 'input' => 'a',
# 'name' => 'is& (ok)',
# 'schema' => [
# 'str',
# 'is&',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:str) is& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 48 - (tags=clause:is, op, op:and, opshortcut, type, type:str) is& (ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is& (nok + ok)',
# 'schema' => [
# 'str',
# 'is&',
# [
# 'b',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:str) is& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 49 - (tags=clause:is, op, op:and, opshortcut, type, type:str) is& (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is& (ok + nok)',
# 'schema' => [
# 'str',
# 'is&',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:str) is& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 50 - (tags=clause:is, op, op:and, opshortcut, type, type:str) is& (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is& (nok + nok)',
# 'schema' => [
# 'str',
# 'is&',
# [
# 'b',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, opshortcut, type, type:str) is& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 51 - (tags=clause:is, op, op:and, opshortcut, type, type:str) is& (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'is.op=and (no items)',
# 'schema' => [
# 'str',
# 'is',
# [],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:str) is.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 52 - (tags=type, type:str) is.op=and (no items)
# {
# 'input' => 'a',
# 'name' => 'is.op=and (ok)',
# 'schema' => [
# 'str',
# 'is',
# [
# 'a',
# 'a'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:and, type, type:str) is.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 53 - (tags=clause:is, op, op:and, type, type:str) is.op=and (ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=and (nok + ok)',
# 'schema' => [
# 'str',
# 'is',
# [
# 'b',
# 'a'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:str) is.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 54 - (tags=clause:is, op, op:and, type, type:str) is.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=and (ok + nok)',
# 'schema' => [
# 'str',
# 'is',
# [
# 'a',
# 'b'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:str) is.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 55 - (tags=clause:is, op, op:and, type, type:str) is.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=and (nok + nok)',
# 'schema' => [
# 'str',
# 'is',
# [
# 'b',
# 'b'
# ],
# 'is.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:and, type, type:str) is.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 56 - (tags=clause:is, op, op:and, type, type:str) is.op=and (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'is| (no items)',
# 'schema' => [
# 'str',
# 'is|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:str) is| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 57 - (tags=clause:is, op, op:or, opshortcut, type, type:str) is| (no items)
# {
# 'input' => 'a',
# 'name' => 'is| (ok)',
# 'schema' => [
# 'str',
# 'is|',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:str) is| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 58 - (tags=clause:is, op, op:or, opshortcut, type, type:str) is| (ok)
# {
# 'input' => 'a',
# 'name' => 'is| (nok + ok)',
# 'schema' => [
# 'str',
# 'is|',
# [
# 'b',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:str) is| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 59 - (tags=clause:is, op, op:or, opshortcut, type, type:str) is| (nok + ok)
# {
# 'input' => 'a',
# 'name' => 'is| (ok + nok)',
# 'schema' => [
# 'str',
# 'is|',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:str) is| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 60 - (tags=clause:is, op, op:or, opshortcut, type, type:str) is| (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is| (nok + nok)',
# 'schema' => [
# 'str',
# 'is|',
# [
# 'b',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, opshortcut, type, type:str) is| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 61 - (tags=clause:is, op, op:or, opshortcut, type, type:str) is| (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'is.op=or (no items)',
# 'schema' => [
# 'str',
# 'is',
# [],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:str) is.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 62 - (tags=clause:is, op, op:or, type, type:str) is.op=or (no items)
# {
# 'input' => 'a',
# 'name' => 'is.op=or (ok)',
# 'schema' => [
# 'str',
# 'is',
# [
# 'a',
# 'a'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:str) is.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 63 - (tags=clause:is, op, op:or, type, type:str) is.op=or (ok)
# {
# 'input' => 'a',
# 'name' => 'is.op=or (nok + ok)',
# 'schema' => [
# 'str',
# 'is',
# [
# 'b',
# 'a'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:str) is.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 64 - (tags=clause:is, op, op:or, type, type:str) is.op=or (nok + ok)
# {
# 'input' => 'a',
# 'name' => 'is.op=or (ok + nok)',
# 'schema' => [
# 'str',
# 'is',
# [
# 'a',
# 'b'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:or, type, type:str) is.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 65 - (tags=clause:is, op, op:or, type, type:str) is.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=or (nok + nok)',
# 'schema' => [
# 'str',
# 'is',
# [
# 'b',
# 'b'
# ],
# 'is.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:or, type, type:str) is.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 66 - (tags=clause:is, op, op:or, type, type:str) is.op=or (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'is.op=none (empty items)',
# 'schema' => [
# 'str',
# 'is',
# [],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:str) is.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 67 - (tags=clause:is, op, op:none, type, type:str) is.op=none (empty items)
# {
# 'input' => 'a',
# 'name' => 'is.op=none (nok + nok)',
# 'schema' => [
# 'str',
# 'is',
# [
# 'b',
# 'b'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is, op, op:none, type, type:str) is.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 68 - (tags=clause:is, op, op:none, type, type:str) is.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=none (nok + ok)',
# 'schema' => [
# 'str',
# 'is',
# [
# 'b',
# 'a'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:str) is.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 69 - (tags=clause:is, op, op:none, type, type:str) is.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=none (ok + nok)',
# 'schema' => [
# 'str',
# 'is',
# [
# 'a',
# 'b'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:str) is.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 70 - (tags=clause:is, op, op:none, type, type:str) is.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'is.op=none (ok + ok)',
# 'schema' => [
# 'str',
# 'is',
# [
# 'a',
# 'a'
# ],
# 'is.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is, op, op:none, type, type:str) is.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 71 - (tags=clause:is, op, op:none, type, type:str) is.op=none (ok + ok)
# {
# 'input' => 'a',
# 'name' => 'in: must accept valid choices',
# 'schema' => [
# 'str',
# 'in',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, type, type:str) in: must accept valid choices
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 72 - (tags=clause:in, type, type:str) in: must accept valid choices
# {
# 'input' => 'a',
# 'name' => 'in: must reject empty choices',
# 'schema' => [
# 'str',
# 'in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, type, type:str) in: must reject empty choices
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 73 - (tags=clause:in, type, type:str) in: must reject empty choices
# {
# 'input' => 'a',
# 'name' => '!in (nok)',
# 'schema' => [
# 'str',
# '!in',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:str) !in (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 74 - (tags=clause:in, op, op:not, opshortcut, type, type:str) !in (nok)
# {
# 'input' => 'a',
# 'name' => '!in (ok)',
# 'schema' => [
# 'str',
# '!in',
# []
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, opshortcut, type, type:str) !in (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 75 - (tags=clause:in, op, op:not, opshortcut, type, type:str) !in (ok)
# {
# 'input' => 'a',
# 'name' => 'in.op=not (nok)',
# 'schema' => [
# 'str',
# 'in',
# [
# 'a',
# 'b'
# ],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:not, type, type:str) in.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 76 - (tags=clause:in, op, op:not, type, type:str) in.op=not (nok)
# {
# 'input' => 'a',
# 'name' => 'in.op=not (ok)',
# 'schema' => [
# 'str',
# 'in',
# [],
# 'in.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:not, type, type:str) in.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 77 - (tags=clause:in, op, op:not, type, type:str) in.op=not (ok)
# {
# 'input' => 'a',
# 'name' => 'in& (no items)',
# 'schema' => [
# 'str',
# 'in&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:str) in& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 78 - (tags=clause:in, op, op:and, opshortcut, type, type:str) in& (no items)
# {
# 'input' => 'a',
# 'name' => 'in& (ok)',
# 'schema' => [
# 'str',
# 'in&',
# [
# [
# 'a',
# 'b'
# ],
# [
# 'a',
# 'b'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:str) in& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 79 - (tags=clause:in, op, op:and, opshortcut, type, type:str) in& (ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in& (nok + ok)',
# 'schema' => [
# 'str',
# 'in&',
# [
# [],
# [
# 'a',
# 'b'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:str) in& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 80 - (tags=clause:in, op, op:and, opshortcut, type, type:str) in& (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in& (ok + nok)',
# 'schema' => [
# 'str',
# 'in&',
# [
# [
# 'a',
# 'b'
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:str) in& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 81 - (tags=clause:in, op, op:and, opshortcut, type, type:str) in& (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in& (nok + nok)',
# 'schema' => [
# 'str',
# 'in&',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, opshortcut, type, type:str) in& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 82 - (tags=clause:in, op, op:and, opshortcut, type, type:str) in& (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'in.op=and (no items)',
# 'schema' => [
# 'str',
# 'in',
# [],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:str) in.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 83 - (tags=type, type:str) in.op=and (no items)
# {
# 'input' => 'a',
# 'name' => 'in.op=and (ok)',
# 'schema' => [
# 'str',
# 'in',
# [
# [
# 'a',
# 'b'
# ],
# [
# 'a',
# 'b'
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:and, type, type:str) in.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 84 - (tags=clause:in, op, op:and, type, type:str) in.op=and (ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=and (nok + ok)',
# 'schema' => [
# 'str',
# 'in',
# [
# [],
# [
# 'a',
# 'b'
# ]
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:str) in.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 85 - (tags=clause:in, op, op:and, type, type:str) in.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=and (ok + nok)',
# 'schema' => [
# 'str',
# 'in',
# [
# [
# 'a',
# 'b'
# ],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:str) in.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 86 - (tags=clause:in, op, op:and, type, type:str) in.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=and (nok + nok)',
# 'schema' => [
# 'str',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:and, type, type:str) in.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 87 - (tags=clause:in, op, op:and, type, type:str) in.op=and (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'in| (no items)',
# 'schema' => [
# 'str',
# 'in|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:str) in| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 88 - (tags=clause:in, op, op:or, opshortcut, type, type:str) in| (no items)
# {
# 'input' => 'a',
# 'name' => 'in| (ok)',
# 'schema' => [
# 'str',
# 'in|',
# [
# [
# 'a',
# 'b'
# ],
# [
# 'a',
# 'b'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:str) in| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 89 - (tags=clause:in, op, op:or, opshortcut, type, type:str) in| (ok)
# {
# 'input' => 'a',
# 'name' => 'in| (nok + ok)',
# 'schema' => [
# 'str',
# 'in|',
# [
# [],
# [
# 'a',
# 'b'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:str) in| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 90 - (tags=clause:in, op, op:or, opshortcut, type, type:str) in| (nok + ok)
# {
# 'input' => 'a',
# 'name' => 'in| (ok + nok)',
# 'schema' => [
# 'str',
# 'in|',
# [
# [
# 'a',
# 'b'
# ],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:str) in| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 91 - (tags=clause:in, op, op:or, opshortcut, type, type:str) in| (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in| (nok + nok)',
# 'schema' => [
# 'str',
# 'in|',
# [
# [],
# []
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, opshortcut, type, type:str) in| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 92 - (tags=clause:in, op, op:or, opshortcut, type, type:str) in| (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'in.op=or (no items)',
# 'schema' => [
# 'str',
# 'in',
# [],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:str) in.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 93 - (tags=clause:in, op, op:or, type, type:str) in.op=or (no items)
# {
# 'input' => 'a',
# 'name' => 'in.op=or (ok)',
# 'schema' => [
# 'str',
# 'in',
# [
# [
# 'a',
# 'b'
# ],
# [
# 'a',
# 'b'
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:str) in.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 94 - (tags=clause:in, op, op:or, type, type:str) in.op=or (ok)
# {
# 'input' => 'a',
# 'name' => 'in.op=or (nok + ok)',
# 'schema' => [
# 'str',
# 'in',
# [
# [],
# [
# 'a',
# 'b'
# ]
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:str) in.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 95 - (tags=clause:in, op, op:or, type, type:str) in.op=or (nok + ok)
# {
# 'input' => 'a',
# 'name' => 'in.op=or (ok + nok)',
# 'schema' => [
# 'str',
# 'in',
# [
# [
# 'a',
# 'b'
# ],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:or, type, type:str) in.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 96 - (tags=clause:in, op, op:or, type, type:str) in.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=or (nok + nok)',
# 'schema' => [
# 'str',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:or, type, type:str) in.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 97 - (tags=clause:in, op, op:or, type, type:str) in.op=or (nok + nok)
# {
# 'input' => 'a',
# 'name' => 'in.op=none (empty items)',
# 'schema' => [
# 'str',
# 'in',
# [],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:str) in.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 98 - (tags=clause:in, op, op:none, type, type:str) in.op=none (empty items)
# {
# 'input' => 'a',
# 'name' => 'in.op=none (nok + nok)',
# 'schema' => [
# 'str',
# 'in',
# [
# [],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:in, op, op:none, type, type:str) in.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 99 - (tags=clause:in, op, op:none, type, type:str) in.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=none (nok + ok)',
# 'schema' => [
# 'str',
# 'in',
# [
# [],
# [
# 'a',
# 'b'
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:str) in.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 100 - (tags=clause:in, op, op:none, type, type:str) in.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=none (ok + nok)',
# 'schema' => [
# 'str',
# 'in',
# [
# [
# 'a',
# 'b'
# ],
# []
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:str) in.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 101 - (tags=clause:in, op, op:none, type, type:str) in.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => 'a',
# 'name' => 'in.op=none (ok + ok)',
# 'schema' => [
# 'str',
# 'in',
# [
# [
# 'a',
# 'b'
# ],
# [
# 'a',
# 'b'
# ]
# ],
# 'in.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:in',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:in, op, op:none, type, type:str) in.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 102 - (tags=clause:in, op, op:none, type, type:str) in.op=none (ok + ok)
# {
# 'input' => 'a',
# 'name' => 'min: a ',
# 'schema' => [
# 'str',
# 'min',
# ''
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:str) min: a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 103 - (tags=clause:min, type, type:str) min: a
# {
# 'input' => 'a',
# 'name' => 'min: a a',
# 'schema' => [
# 'str',
# 'min',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:min'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min, type, type:str) min: a a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 104 - (tags=clause:min, type, type:str) min: a a
# {
# 'input' => '',
# 'name' => 'min: a -> fail',
# 'schema' => [
# 'str',
# 'min',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:min'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:min, type, type:str) min: a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 105 - (tags=clause:min, type, type:str) min: a -> fail
# {
# 'input' => 'a',
# 'name' => 'xmin: a ',
# 'schema' => [
# 'str',
# 'xmin',
# ''
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:xmin'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmin, type, type:str) xmin: a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 106 - (tags=clause:xmin, type, type:str) xmin: a
# {
# 'input' => 'a',
# 'name' => 'xmin: a a -> fail',
# 'schema' => [
# 'str',
# 'xmin',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:str) xmin: a a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 107 - (tags=clause:xmin, type, type:str) xmin: a a -> fail
# {
# 'input' => '',
# 'name' => 'xmin: a -> fail',
# 'schema' => [
# 'str',
# 'xmin',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:xmin'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmin, type, type:str) xmin: a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 108 - (tags=clause:xmin, type, type:str) xmin: a -> fail
# {
# 'input' => 'a',
# 'name' => 'max: a -> fail',
# 'schema' => [
# 'str',
# 'max',
# ''
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:max'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:max, type, type:str) max: a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 109 - (tags=clause:max, type, type:str) max: a -> fail
# {
# 'input' => 'a',
# 'name' => 'max: a a',
# 'schema' => [
# 'str',
# 'max',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:str) max: a a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 110 - (tags=clause:max, type, type:str) max: a a
# {
# 'input' => '',
# 'name' => 'max: a',
# 'schema' => [
# 'str',
# 'max',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:max'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max, type, type:str) max: a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 111 - (tags=clause:max, type, type:str) max: a
# {
# 'input' => 'a',
# 'name' => 'xmax: a -> fail',
# 'schema' => [
# 'str',
# 'xmax',
# ''
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:str) xmax: a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 112 - (tags=clause:xmax, type, type:str) xmax: a -> fail
# {
# 'input' => 'a',
# 'name' => 'xmax: a a -> fail',
# 'schema' => [
# 'str',
# 'xmax',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:xmax'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xmax, type, type:str) xmax: a a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 113 - (tags=clause:xmax, type, type:str) xmax: a a -> fail
# {
# 'input' => '',
# 'name' => 'xmax: a',
# 'schema' => [
# 'str',
# 'xmax',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:xmax'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xmax, type, type:str) xmax: a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 114 - (tags=clause:xmax, type, type:str) xmax: a
# {
# 'input' => 'a',
# 'name' => 'between: a & ab',
# 'schema' => [
# 'str',
# 'between',
# [
# '',
# 'ab'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:str) between: a & ab
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 115 - (tags=clause:between, type, type:str) between: a & ab
# {
# 'input' => 'a',
# 'name' => 'between: a & a',
# 'schema' => [
# 'str',
# 'between',
# [
# '',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:str) between: a & a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 116 - (tags=clause:between, type, type:str) between: a & a
# {
# 'input' => 'a',
# 'name' => 'between: a a & a',
# 'schema' => [
# 'str',
# 'between',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, type, type:str) between: a a & a
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 117 - (tags=clause:between, type, type:str) between: a a & a
# {
# 'input' => '',
# 'name' => 'between: a & ab -> fail',
# 'schema' => [
# 'str',
# 'between',
# [
# 'a',
# 'ab'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, type, type:str) between: a & ab -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 118 - (tags=clause:between, type, type:str) between: a & ab -> fail
# {
# 'input' => 'a',
# 'name' => 'xbetween: a & ab',
# 'schema' => [
# 'str',
# 'xbetween',
# [
# '',
# 'ab'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:xbetween'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:xbetween, type, type:str) xbetween: a & ab
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 119 - (tags=clause:xbetween, type, type:str) xbetween: a & ab
# {
# 'input' => 'a',
# 'name' => 'xbetween: a & a -> fail',
# 'schema' => [
# 'str',
# 'xbetween',
# [
# '',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:str) xbetween: a & a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 120 - (tags=clause:xbetween, type, type:str) xbetween: a & a -> fail
# {
# 'input' => 'a',
# 'name' => 'xbetween: a a & a -> fail',
# 'schema' => [
# 'str',
# 'xbetween',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:str) xbetween: a a & a -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 121 - (tags=clause:xbetween, type, type:str) xbetween: a a & a -> fail
# {
# 'input' => '',
# 'name' => 'xbetween: a & ab -> fail',
# 'schema' => [
# 'str',
# 'xbetween',
# [
# 'a',
# 'ab'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:xbetween'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:xbetween, type, type:str) xbetween: a & ab -> fail
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 122 - (tags=clause:xbetween, type, type:str) xbetween: a & ab -> fail
# {
# 'input' => '',
# 'name' => '!between (nok)',
# 'schema' => [
# 'str',
# '!between',
# [
# '',
# ''
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:not, opshortcut, type, type:str) !between (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 123 - (tags=clause:between, op, op:not, opshortcut, type, type:str) !between (nok)
# {
# 'input' => '',
# 'name' => '!between (ok)',
# 'schema' => [
# 'str',
# '!between',
# [
# 'a',
# 'a'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:not, opshortcut, type, type:str) !between (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 124 - (tags=clause:between, op, op:not, opshortcut, type, type:str) !between (ok)
# {
# 'input' => '',
# 'name' => 'between.op=not (nok)',
# 'schema' => [
# 'str',
# 'between',
# [
# '',
# ''
# ],
# 'between.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:not'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:not, type, type:str) between.op=not (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 125 - (tags=clause:between, op, op:not, type, type:str) between.op=not (nok)
# {
# 'input' => '',
# 'name' => 'between.op=not (ok)',
# 'schema' => [
# 'str',
# 'between',
# [
# 'a',
# 'a'
# ],
# 'between.op',
# 'not'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:not'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:not, type, type:str) between.op=not (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 126 - (tags=clause:between, op, op:not, type, type:str) between.op=not (ok)
# {
# 'input' => '',
# 'name' => 'between& (no items)',
# 'schema' => [
# 'str',
# 'between&',
# []
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:str) between& (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 127 - (tags=clause:between, op, op:and, opshortcut, type, type:str) between& (no items)
# {
# 'input' => '',
# 'name' => 'between& (ok)',
# 'schema' => [
# 'str',
# 'between&',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:str) between& (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 128 - (tags=clause:between, op, op:and, opshortcut, type, type:str) between& (ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between& (nok + ok)',
# 'schema' => [
# 'str',
# 'between&',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:str) between& (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 129 - (tags=clause:between, op, op:and, opshortcut, type, type:str) between& (nok + ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between& (ok + nok)',
# 'schema' => [
# 'str',
# 'between&',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:str) between& (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 130 - (tags=clause:between, op, op:and, opshortcut, type, type:str) between& (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between& (nok + nok)',
# 'schema' => [
# 'str',
# 'between&',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, opshortcut, type, type:str) between& (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 131 - (tags=clause:between, op, op:and, opshortcut, type, type:str) between& (nok + nok)
# {
# 'input' => '',
# 'name' => 'between.op=and (no items)',
# 'schema' => [
# 'str',
# 'between',
# [],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:str) between.op=and (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 132 - (tags=type, type:str) between.op=and (no items)
# {
# 'input' => '',
# 'name' => 'between.op=and (ok)',
# 'schema' => [
# 'str',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:and, type, type:str) between.op=and (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 133 - (tags=clause:between, op, op:and, type, type:str) between.op=and (ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=and (nok + ok)',
# 'schema' => [
# 'str',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:str) between.op=and (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 134 - (tags=clause:between, op, op:and, type, type:str) between.op=and (nok + ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=and (ok + nok)',
# 'schema' => [
# 'str',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:str) between.op=and (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 135 - (tags=clause:between, op, op:and, type, type:str) between.op=and (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=and (nok + nok)',
# 'schema' => [
# 'str',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'and'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:and'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:and, type, type:str) between.op=and (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 136 - (tags=clause:between, op, op:and, type, type:str) between.op=and (nok + nok)
# {
# 'input' => '',
# 'name' => 'between| (no items)',
# 'schema' => [
# 'str',
# 'between|',
# []
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:str) between| (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 137 - (tags=clause:between, op, op:or, opshortcut, type, type:str) between| (no items)
# {
# 'input' => '',
# 'name' => 'between| (ok)',
# 'schema' => [
# 'str',
# 'between|',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:str) between| (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 138 - (tags=clause:between, op, op:or, opshortcut, type, type:str) between| (ok)
# {
# 'input' => '',
# 'name' => 'between| (nok + ok)',
# 'schema' => [
# 'str',
# 'between|',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:str) between| (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 139 - (tags=clause:between, op, op:or, opshortcut, type, type:str) between| (nok + ok)
# {
# 'input' => '',
# 'name' => 'between| (ok + nok)',
# 'schema' => [
# 'str',
# 'between|',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:str) between| (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 140 - (tags=clause:between, op, op:or, opshortcut, type, type:str) between| (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between| (nok + nok)',
# 'schema' => [
# 'str',
# 'between|',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:or, opshortcut, type, type:str) between| (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 141 - (tags=clause:between, op, op:or, opshortcut, type, type:str) between| (nok + nok)
# {
# 'input' => '',
# 'name' => 'between.op=or (no items)',
# 'schema' => [
# 'str',
# 'between',
# [],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:str) between.op=or (no items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 142 - (tags=clause:between, op, op:or, type, type:str) between.op=or (no items)
# {
# 'input' => '',
# 'name' => 'between.op=or (ok)',
# 'schema' => [
# 'str',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:str) between.op=or (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 143 - (tags=clause:between, op, op:or, type, type:str) between.op=or (ok)
# {
# 'input' => '',
# 'name' => 'between.op=or (nok + ok)',
# 'schema' => [
# 'str',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:str) between.op=or (nok + ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 144 - (tags=clause:between, op, op:or, type, type:str) between.op=or (nok + ok)
# {
# 'input' => '',
# 'name' => 'between.op=or (ok + nok)',
# 'schema' => [
# 'str',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:or, type, type:str) between.op=or (ok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 145 - (tags=clause:between, op, op:or, type, type:str) between.op=or (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=or (nok + nok)',
# 'schema' => [
# 'str',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'or'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:or'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:or, type, type:str) between.op=or (nok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 146 - (tags=clause:between, op, op:or, type, type:str) between.op=or (nok + nok)
# {
# 'input' => '',
# 'name' => 'between.op=none (empty items)',
# 'schema' => [
# 'str',
# 'between',
# [],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:none, type, type:str) between.op=none (empty items)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 147 - (tags=clause:between, op, op:none, type, type:str) between.op=none (empty items)
# {
# 'input' => '',
# 'name' => 'between.op=none (nok + nok)',
# 'schema' => [
# 'str',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:between, op, op:none, type, type:str) between.op=none (nok + nok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 148 - (tags=clause:between, op, op:none, type, type:str) between.op=none (nok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=none (nok + ok)',
# 'schema' => [
# 'str',
# 'between',
# [
# [
# 'a',
# 'a'
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:str) between.op=none (nok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 149 - (tags=clause:between, op, op:none, type, type:str) between.op=none (nok + ok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=none (ok + nok)',
# 'schema' => [
# 'str',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# 'a',
# 'a'
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:str) between.op=none (ok + nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 150 - (tags=clause:between, op, op:none, type, type:str) between.op=none (ok + nok)
# {
# 'errors' => 1,
# 'input' => '',
# 'name' => 'between.op=none (ok + ok)',
# 'schema' => [
# 'str',
# 'between',
# [
# [
# '',
# ''
# ],
# [
# '',
# ''
# ]
# ],
# 'between.op',
# 'none'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:between',
# 'op',
# 'op:none'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:between, op, op:none, type, type:str) between.op=none (ok + ok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 151 - (tags=clause:between, op, op:none, type, type:str) between.op=none (ok + ok)
# {
# 'input' => 'a',
# 'name' => 'len (ok)',
# 'schema' => [
# 'str',
# 'len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:len, type, type:str) len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 152 - (tags=clause:len, type, type:str) len (ok)
# {
# 'input' => 'a',
# 'name' => 'len (nok)',
# 'schema' => [
# 'str',
# 'len',
# 3
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:len, type, type:str) len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 153 - (tags=clause:len, type, type:str) len (nok)
# {
# 'input' => 'a',
# 'name' => 'min_len (ok)',
# 'schema' => [
# 'str',
# 'min_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:min_len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:min_len, type, type:str) min_len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 154 - (tags=clause:min_len, type, type:str) min_len (ok)
# {
# 'input' => 'a',
# 'name' => 'min_len (nok)',
# 'schema' => [
# 'str',
# 'min_len',
# 3
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:min_len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:min_len, type, type:str) min_len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 155 - (tags=clause:min_len, type, type:str) min_len (nok)
# {
# 'input' => 'a',
# 'name' => 'max_len (ok)',
# 'schema' => [
# 'str',
# 'min_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:max_len'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:max_len, type, type:str) max_len (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 156 - (tags=clause:max_len, type, type:str) max_len (ok)
# {
# 'input' => 'abc',
# 'name' => 'max_len (nok)',
# 'schema' => [
# 'str',
# 'max_len',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:max_len'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:max_len, type, type:str) max_len (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 157 - (tags=clause:max_len, type, type:str) max_len (nok)
# {
# 'input' => 'a',
# 'name' => 'len_between (ok)',
# 'schema' => [
# 'str',
# 'len_between',
# [
# 1,
# 3
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:len_between'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:len_between, type, type:str) len_between (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 158 - (tags=clause:len_between, type, type:str) len_between (ok)
# {
# 'input' => 'abc',
# 'name' => 'len_between (nok)',
# 'schema' => [
# 'str',
# 'len_between',
# [
# 1,
# 1
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:len_between'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:len_between, type, type:str) len_between (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 159 - (tags=clause:len_between, type, type:str) len_between (nok)
# {
# 'input' => 'abc',
# 'name' => 'each_index (ok)',
# 'schema' => [
# 'str',
# 'each_index',
# [
# 'int',
# 'max',
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:each_index'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:each_index, type, type:str) each_index (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 160 - (tags=clause:each_index, type, type:str) each_index (ok)
# {
# 'input' => 'abc',
# 'name' => 'each_index (nok)',
# 'schema' => [
# 'str',
# 'each_index',
# [
# 'int',
# 'xmax',
# 2
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:each_index'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:each_index, type, type:str) each_index (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 161 - (tags=clause:each_index, type, type:str) each_index (nok)
# {
# 'input' => 'abc',
# 'name' => 'each_elem (ok)',
# 'schema' => [
# 'str',
# 'each_elem',
# 'str'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:each_elem'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:each_elem, type, type:str) each_elem (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 162 - (tags=clause:each_elem, type, type:str) each_elem (ok)
# {
# 'input' => 'abc',
# 'name' => 'each_elem (nok)',
# 'schema' => [
# 'str',
# 'each_elem',
# 'float'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:each_elem'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:each_elem, type, type:str) each_elem (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 163 - (tags=clause:each_elem, type, type:str) each_elem (nok)
# {
# 'invalid_inputs' => [
# '',
# 'A',
# 'c'
# ],
# 'name' => 'has',
# 'schema' => [
# 'str',
# 'has',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:has'
# ],
# 'valid_inputs' => [
# 'abc',
# 'ac'
# ]
# }
# Subtest: (tags=clause:has, type, type:str) has
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - invalid input [2]
ok 7 - validator (rt=full) returns hash
1..7
ok 164 - (tags=clause:has, type, type:str) has
# {
# 'invalid_inputs' => [
# 'abc',
# 'ac'
# ],
# 'name' => 'has + op.not',
# 'schema' => [
# 'str',
# '!has',
# 'a'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:has',
# 'op',
# 'op:not',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# '',
# 'A',
# 'c'
# ]
# }
# Subtest: (tags=clause:has, op, op:not, opshortcut, type, type:str) has + op.not
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - valid input [2]
ok 5 - invalid input [0]
ok 6 - invalid input [1]
ok 7 - validator (rt=full) returns hash
1..7
ok 165 - (tags=clause:has, op, op:not, opshortcut, type, type:str) has + op.not
# {
# 'invalid_inputs' => [
# '',
# 'A',
# 'c'
# ],
# 'name' => 'has + op.or',
# 'schema' => [
# 'str',
# 'has|',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:has',
# 'op',
# 'op:or',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# 'abc',
# 'ac'
# ]
# }
# Subtest: (tags=clause:has, op, op:or, opshortcut, type, type:str) has + op.or
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - valid input [1]
ok 4 - invalid input [0]
ok 5 - invalid input [1]
ok 6 - invalid input [2]
ok 7 - validator (rt=full) returns hash
1..7
ok 166 - (tags=clause:has, op, op:or, opshortcut, type, type:str) has + op.or
# {
# 'invalid_inputs' => [
# 'ac',
# '',
# 'A',
# 'c'
# ],
# 'name' => 'has + op.and',
# 'schema' => [
# 'str',
# 'has&',
# [
# 'a',
# 'b'
# ]
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:has',
# 'op',
# 'op:and',
# 'opshortcut'
# ],
# 'valid_inputs' => [
# 'abc'
# ]
# }
# Subtest: (tags=clause:has, op, op:and, opshortcut, type, type:str) has + op.and
ok 1 - compile success
ok 2 - valid input [0]
ok 3 - invalid input [0]
ok 4 - invalid input [1]
ok 5 - invalid input [2]
ok 6 - invalid input [3]
ok 7 - validator (rt=full) returns hash
1..7
ok 167 - (tags=clause:has, op, op:and, opshortcut, type, type:str) has + op.and
# {
# 'input' => 'a',
# 'name' => 'match: (ok)',
# 'schema' => [
# 'str',
# 'match',
# '[abc]'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:match'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:match, type, type:str) match: (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 168 - (tags=clause:match, type, type:str) match: (ok)
# {
# 'input' => 'A',
# 'name' => 'match: (nok)',
# 'schema' => [
# 'str',
# 'match',
# '[abc]'
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:match'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:match, type, type:str) match: (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 169 - (tags=clause:match, type, type:str) match: (nok)
# {
# 'dies' => 1,
# 'input' => 'a',
# 'name' => 'match: (dies, invalid regex)',
# 'schema' => [
# 'str',
# 'match',
# '('
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:match'
# ]
# }
# Subtest: (tags=clause:match, type, type:str) match: (dies, invalid regex)
ok 1 - compile error
1..1
ok 170 - (tags=clause:match, type, type:str) match: (dies, invalid regex)
# {
# 'input' => 'a',
# 'name' => 'is_re: 1 (ok)',
# 'schema' => [
# 'str',
# 'is_re',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is_re'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is_re, type, type:str) is_re: 1 (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 171 - (tags=clause:is_re, type, type:str) is_re: 1 (ok)
# {
# 'input' => 'a(',
# 'name' => 'is_re: 1 (nok)',
# 'schema' => [
# 'str',
# 'is_re',
# 1
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is_re'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is_re, type, type:str) is_re: 1 (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 172 - (tags=clause:is_re, type, type:str) is_re: 1 (nok)
# {
# 'input' => 'a(',
# 'name' => 'is_re: 0 (ok)',
# 'schema' => [
# 'str',
# 'is_re',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is_re'
# ],
# 'valid' => 1
# }
# Subtest: (tags=clause:is_re, type, type:str) is_re: 0 (ok)
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 173 - (tags=clause:is_re, type, type:str) is_re: 0 (ok)
# {
# 'input' => 'a',
# 'name' => 'is_re: 0 (nok)',
# 'schema' => [
# 'str',
# 'is_re',
# 0
# ],
# 'tags' => [
# 'type',
# 'type:str',
# 'clause:is_re'
# ],
# 'valid' => 0
# }
# Subtest: (tags=clause:is_re, type, type:str) is_re: 0 (nok)
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 174 - (tags=clause:is_re, type, type:str) is_re: 0 (nok)
ok 175
1..175
ok 14 - 10-type-str.json
# Subtest: 10-type-undef.json
# Test version: v0.9.29 (generated by devscripts/gen-type-spectest on Mon Nov 25 15:43:40 2013)
# {
# 'input' => undef,
# 'name' => 'ok',
# 'schema' => [
# 'undef'
# ],
# 'tags' => [
# 'type',
# 'type:undef'
# ],
# 'valid' => 1
# }
# Subtest: (tags=type, type:undef) ok
ok 1 - compile success
ok 2 - valid (rt=bool)
ok 3 - valid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 1 - (tags=type, type:undef) ok
# {
# 'input' => 0,
# 'name' => 'nok',
# 'schema' => [
# 'undef'
# ],
# 'tags' => [
# 'type',
# 'type:undef'
# ],
# 'valid' => 0
# }
# Subtest: (tags=type, type:undef) nok
ok 1 - compile success
ok 2 - invalid (rt=bool)
ok 3 - invalid (rt=str)
ok 4 - validator (rt=full) returns hash
ok 5 - errors (rt=full)
ok 6 - warnings (rt=full)
1..6
ok 2 - (tags=type, type:undef) nok
ok 3
1..3
ok 15 - 10-type-undef.json
1..15
ok
All tests successful.
Files=16, Tests=164, 45 wallclock secs ( 2.58 usr + 0.14 sys = 2.72 CPU)
Result: PASS
SHARYANTO/Data-Sah-0.22.tar.gz
Tests succeeded but 2 dependencies missing (Language::Expr,Language::Expr::Interpreter::VarEnumer)
SHARYANTO/Data-Sah-0.22.tar.gz
[dependencies] -- NA
Running test for module 'Perinci::Sub::GetArgs::Array'
Running make for S/SH/SHARYANTO/Perinci-Sub-GetArgs-Array-0.12.tar.gz
Checksum for C:\cpanfly-5.18\var\cpan\sources\authors\id\S\SH\SHARYANTO\Perinci-Sub-GetArgs-Array-0.12.tar.gz ok
Perinci-Sub-GetArgs-Array-0.12/
Perinci-Sub-GetArgs-Array-0.12/README
Perinci-Sub-GetArgs-Array-0.12/lib/
Perinci-Sub-GetArgs-Array-0.12/lib/Perinci/
Perinci-Sub-GetArgs-Array-0.12/lib/Perinci/Sub/
Perinci-Sub-GetArgs-Array-0.12/lib/Perinci/Sub/GetArgs/
Perinci-Sub-GetArgs-Array-0.12/lib/Perinci/Sub/GetArgs/Array.pm
Perinci-Sub-GetArgs-Array-0.12/Makefile.PL
Perinci-Sub-GetArgs-Array-0.12/Changes
Perinci-Sub-GetArgs-Array-0.12/dist.ini
Perinci-Sub-GetArgs-Array-0.12/LICENSE
Perinci-Sub-GetArgs-Array-0.12/t/
Perinci-Sub-GetArgs-Array-0.12/t/00-compile.t
Perinci-Sub-GetArgs-Array-0.12/t/01-basics.t
Perinci-Sub-GetArgs-Array-0.12/t/release-pod-coverage.t
Perinci-Sub-GetArgs-Array-0.12/t/release-pod-syntax.t
Perinci-Sub-GetArgs-Array-0.12/t/release-rinci.t
Perinci-Sub-GetArgs-Array-0.12/weaver.ini
Perinci-Sub-GetArgs-Array-0.12/MANIFEST
Perinci-Sub-GetArgs-Array-0.12/META.json
Perinci-Sub-GetArgs-Array-0.12/META.yml
CPAN.pm: Building S/SH/SHARYANTO/Perinci-Sub-GetArgs-Array-0.12.tar.gz
>>> C:\Perl64-5.18\bin\perl.exe Makefile.PL
Warning: prerequisite Data::Sah 0 not found.
Checking if your kit is complete...
Looks good
Generating a dmake-style Makefile
Writing Makefile for Perinci::Sub::GetArgs::Array
Writing MYMETA.yml and MYMETA.json
---- Unsatisfied dependencies detected during ----
---- SHARYANTO/Perinci-Sub-GetArgs-Array-0.12.tar.gz ----
Data::Sah [requires]
Running make test
Delayed until after prerequisites
Running test for module 'Data::Sah'
Running make for S/SH/SHARYANTO/Data-Sah-0.22.tar.gz
Has already been unwrapped into directory C:\cpanfly-5.18\var\cpan\build\Data-Sah-0.22-P_AH5D
Warning: Prerequisite 'Language::Expr::Interpreter::VarEnumer => 0.13' for 'SHARYANTO/Data-Sah-0.22.tar.gz' failed when processing 'SHARYANTO/Language-Expr-0.21.tar.gz' with 'make_test => NO'. Continuing, but chances to succeed are limited.
Warning: Prerequisite 'Language::Expr => 0.13' for 'SHARYANTO/Data-Sah-0.22.tar.gz' failed when processing 'SHARYANTO/Language-Expr-0.21.tar.gz' with 'make_test => NO'. Continuing, but chances to succeed are limited.
Has already been made
Running make test
Has already been tested within this command
Running make for S/SH/SHARYANTO/Perinci-Sub-GetArgs-Array-0.12.tar.gz
Has already been unwrapped into directory C:\cpanfly-5.18\var\cpan\build\Perinci-Sub-GetArgs-Array-0.12-ccuuZa
CPAN.pm: Building S/SH/SHARYANTO/Perinci-Sub-GetArgs-Array-0.12.tar.gz
Warning: Prerequisite 'Data::Sah => 0' for 'SHARYANTO/Perinci-Sub-GetArgs-Array-0.12.tar.gz' failed when processing 'SHARYANTO/Data-Sah-0.22.tar.gz' with 'make_test => NO 2 dependencies missing (Language::Expr,Language::Expr::Interpreter::VarEnumer)'. Continuing, but chances to succeed are limited.
>>> dmake
cp lib/Perinci/Sub/GetArgs/Array.pm blib\lib\Perinci\Sub\GetArgs\Array.pm
SHARYANTO/Perinci-Sub-GetArgs-Array-0.12.tar.gz
dmake -- OK
Running make test
>>> dmake test TEST_VERBOSE=1
C:\Perl64-5.18\bin\perl.exe "-MExtUtils::Command::MM" "-MTest::Harness" "-e" "undef *Test::Harness::Switches; test_harness(1, 'blib\lib', 'blib\arch')" t/*.t
# Failed test 'Perinci/Sub/GetArgs/Array.pm loaded ok'
# at t/00-compile.t line 37.
# got: '512'
# expected: '0'
Can't locate Data/Sah.pm in @INC (you may need to install the Data::Sah module) (@INC contains: C:\cpanfly-5.18\var\cpan\build\Perinci-Sub-GetArgs-Array-0.12-ccuuZa\blib\arch C:\cpanfly-5.18\var\cpan\build\Perinci-Sub-GetArgs-Array-0.12-ccuuZa\blib\lib C:\cpanfly-5.18\var\cpan\build\Perinci-Sub-GetArgs-Array-0.12-ccuuZa\blib\lib C:\cpanfly-5.18\var\cpan\build\Perinci-Sub-GetArgs-Array-0.12-ccuuZa\blib\arch C:/cpanfly-5.18/var/megalib C:/cpanfly-5.18/var/megalib C:/Perl64-5.18/site/lib C:/Perl64-5.18/lib .) at C:\cpanfly-5.18\var\cpan\build\Perinci-Sub-GetArgs-Array-0.12-ccuuZa\blib\lib/Perinci/Sub/GetArgs/Array.pm line 8.
BEGIN failed--compilation aborted at C:\cpanfly-5.18\var\cpan\build\Perinci-Sub-GetArgs-Array-0.12-ccuuZa\blib\lib/Perinci/Sub/GetArgs/Array.pm line 8.
Compilation failed in require at -e line 1.
# Looks like you failed 1 test of 1.
t/00-compile.t ............
1..1
not ok 1 - Perinci/Sub/GetArgs/Array.pm loaded ok
Dubious, test returned 1 (wstat 256, 0x100)
Failed 1/1 subtests
Can't locate Data/Sah.pm in @INC (you may need to install the Data::Sah module) (@INC contains: C:\cpanfly-5.18\var\cpan\build\Perinci-Sub-GetArgs-Array-0.12-ccuuZa\blib\lib C:\cpanfly-5.18\var\cpan\build\Perinci-Sub-GetArgs-Array-0.12-ccuuZa\blib\arch C:/cpanfly-5.18/var/megalib C:/cpanfly-5.18/var/megalib C:/Perl64-5.18/site/lib C:/Perl64-5.18/lib .) at C:\cpanfly-5.18\var\cpan\build\Perinci-Sub-GetArgs-Array-0.12-ccuuZa\blib\lib/Perinci/Sub/GetArgs/Array.pm line 8.
BEGIN failed--compilation aborted at C:\cpanfly-5.18\var\cpan\build\Perinci-Sub-GetArgs-Array-0.12-ccuuZa\blib\lib/Perinci/Sub/GetArgs/Array.pm line 8.
Compilation failed in require at t/01-basics.t line 9.
BEGIN failed--compilation aborted at t/01-basics.t line 9.
t/01-basics.t .............
Dubious, test returned 2 (wstat 512, 0x200)
No subtests run
t/release-pod-coverage.t .. skipped: these tests are for release candidate testing
t/release-pod-syntax.t .... skipped: these tests are for release candidate testing
t/release-rinci.t ......... skipped: these tests are for release candidate testing
Test Summary Report
-------------------
t/00-compile.t (Wstat: 256 Tests: 1 Failed: 1)
Failed test: 1
Non-zero exit status: 1
t/01-basics.t (Wstat: 512 Tests: 0 Failed: 0)
Non-zero exit status: 2
Parse errors: No plan found in TAP output
Files=5, Tests=1, 1 wallclock secs ( 0.08 usr + 0.02 sys = 0.09 CPU)
Result: FAIL
Failed 2/5 test programs. 1/1 subtests failed.
dmake: Error code 255, while making 'test_dynamic'
SHARYANTO/Perinci-Sub-GetArgs-Array-0.12.tar.gz
one dependency not OK (Data::Sah); additionally test harness failed
dmake test TEST_VERBOSE=1 -- NOT OK
//hint// to see the cpan-testers results for installing this module, try:
reports SHARYANTO/Perinci-Sub-GetArgs-Array-0.12.tar.gz
Running test for module 'YAML::Syck'
Running make for T/TO/TODDR/YAML-Syck-1.27.tar.gz
Checksum for C:\cpanfly-5.18\var\cpan\sources\authors\id\T\TO\TODDR\YAML-Syck-1.27.tar.gz ok
YAML-Syck-1.27/
YAML-Syck-1.27/gram.h
YAML-Syck-1.27/emitter.c
YAML-Syck-1.27/Syck.xs
YAML-Syck-1.27/token.c
YAML-Syck-1.27/Makefile.PL
YAML-Syck-1.27/Changes
YAML-Syck-1.27/ppport_sort.h
YAML-Syck-1.27/perl_syck.h
YAML-Syck-1.27/syck_st.h
YAML-Syck-1.27/t/
YAML-Syck-1.27/t/meta.t
YAML-Syck-1.27/t/json-refs.t
YAML-Syck-1.27/t/TestYAML.pm
YAML-Syck-1.27/t/bug/
YAML-Syck-1.27/t/bug/rt-54167.t
YAML-Syck-1.27/t/bug/doesnt-stringify.t
YAML-Syck-1.27/t/bug/rt-49404-double_free.t
YAML-Syck-1.27/t/yaml-dumpinto.t
YAML-Syck-1.27/t/json-numbers.t
YAML-Syck-1.27/t/leak.t
YAML-Syck-1.27/t/yaml-tie.t
YAML-Syck-1.27/t/1-basic.t
YAML-Syck-1.27/t/12-dumpfile.t
YAML-Syck-1.27/t/4-perl_tag_scheme.t
YAML-Syck-1.27/t/11-loadfile.t
YAML-Syck-1.27/t/json-null.t
YAML-Syck-1.27/t/2-scalars.t
YAML-Syck-1.27/t/json-basic.t
YAML-Syck-1.27/t/yaml-implicit-warnings.t
YAML-Syck-1.27/t/json-minus.t
YAML-Syck-1.27/t/yaml-utf.t
YAML-Syck-1.27/t/yaml-blessed-ref.t
YAML-Syck-1.27/t/json-crlf.t
YAML-Syck-1.27/t/yaml-str-colon-first.t
YAML-Syck-1.27/t/json-singlequote.t
YAML-Syck-1.27/t/yaml-alias.t
YAML-Syck-1.27/t/json-dumpinto.t
YAML-Syck-1.27/t/json-empty.t
YAML-Syck-1.27/t/3-objects.t
YAML-Syck-1.27/t/json-loadfile.t
YAML-Syck-1.27/t/load-blessed.t
YAML-Syck-1.27/t/json-circular-ref.t
YAML-Syck-1.27/t/json-indent.t
YAML-Syck-1.27/t/json-newline.t
YAML-Syck-1.27/syck.h
YAML-Syck-1.27/bytecode.c
YAML-Syck-1.27/inc/
YAML-Syck-1.27/inc/parent.pm
YAML-Syck-1.27/inc/Test/
YAML-Syck-1.27/inc/Test/Builder.pm
YAML-Syck-1.27/inc/Test/More.pm
YAML-Syck-1.27/inc/Test/Builder/
YAML-Syck-1.27/inc/Test/Builder/IO/
YAML-Syck-1.27/inc/Test/Builder/IO/Scalar.pm
YAML-Syck-1.27/inc/Test/Builder/Module.pm
YAML-Syck-1.27/inc/PerlIO.pm
YAML-Syck-1.27/inc/Module/
YAML-Syck-1.27/inc/Module/Install/
YAML-Syck-1.27/inc/Module/Install/WriteAll.pm
YAML-Syck-1.27/inc/Module/Install/Makefile.pm
YAML-Syck-1.27/inc/Module/Install/Win32.pm
YAML-Syck-1.27/inc/Module/Install/Can.pm
YAML-Syck-1.27/inc/Module/Install/Fetch.pm
YAML-Syck-1.27/inc/Module/Install/Metadata.pm
YAML-Syck-1.27/inc/Module/Install/Include.pm
YAML-Syck-1.27/inc/Module/Install/Base.pm
YAML-Syck-1.27/inc/Module/Install/Compiler.pm
YAML-Syck-1.27/inc/Module/Install.pm
YAML-Syck-1.27/META.yml
YAML-Syck-1.27/handler.c
YAML-Syck-1.27/perl_common.h
YAML-Syck-1.27/README
YAML-Syck-1.27/node.c
YAML-Syck-1.27/MANIFEST
YAML-Syck-1.27/ppport_math.h
YAML-Syck-1.27/implicit.c
YAML-Syck-1.27/gram.c
YAML-Syck-1.27/syck_.c
YAML-Syck-1.27/ppport.h
YAML-Syck-1.27/COPYING
YAML-Syck-1.27/lib/
YAML-Syck-1.27/lib/JSON/
YAML-Syck-1.27/lib/JSON/Syck.pm
YAML-Syck-1.27/lib/YAML/
YAML-Syck-1.27/lib/YAML/Loader/
YAML-Syck-1.27/lib/YAML/Loader/Syck.pm
YAML-Syck-1.27/lib/YAML/Dumper/
YAML-Syck-1.27/lib/YAML/Dumper/Syck.pm
YAML-Syck-1.27/lib/YAML/Syck.pm
YAML-Syck-1.27/COMPATIBILITY
YAML-Syck-1.27/syck_st.c
CPAN.pm: Building T/TO/TODDR/YAML-Syck-1.27.tar.gz
>>> C:\Perl64-5.18\bin\perl.exe Makefile.PL
Checking if your kit is complete...
Looks good
Generating a dmake-style Makefile
Writing Makefile for YAML::Syck
Writing MYMETA.yml and MYMETA.json
>>> dmake
cp lib/YAML/Syck.pm blib\lib\YAML\Syck.pm
cp lib/JSON/Syck.pm blib\lib\JSON\Syck.pm
cp lib/YAML/Loader/Syck.pm blib\lib\YAML\Loader\Syck.pm
cp lib/YAML/Dumper/Syck.pm blib\lib\YAML\Dumper\Syck.pm
Running Mkbootstrap for YAML::Syck ()
C:\Perl64-5.18\bin\perl.exe "-Iinc" -MExtUtils::Command -e chmod -- 644 Syck.bs
gcc -c -I. -s -O2 -DWIN32 -DWIN64 -DCONSERVATIVE -DPERL_TEXTMODE_SCRIPTS -DUSE_SITECUSTOMIZE -DPERL_IMPLICIT_CONTEXT -DPERL_IMPLICIT_SYS -DUSE_PERLIO -fno-strict-aliasing -mms-bitfields -s -O2 -DVERSION=\"1.27\" -DXS_VERSION=\"1.27\" "-IC:\Perl64-5.18\lib\CORE" bytecode.c
gcc -c -I. -s -O2 -DWIN32 -DWIN64 -DCONSERVATIVE -DPERL_TEXTMODE_SCRIPTS -DUSE_SITECUSTOMIZE -DPERL_IMPLICIT_CONTEXT -DPERL_IMPLICIT_SYS -DUSE_PERLIO -fno-strict-aliasing -mms-bitfields -s -O2 -DVERSION=\"1.27\" -DXS_VERSION=\"1.27\" "-IC:\Perl64-5.18\lib\CORE" emitter.c
emitter.c: In function 'syck_emit':
emitter.c:409:40: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
emitter.c:424:37: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
emitter.c: In function 'syck_emitter_mark_node':
emitter.c:1350:52: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
gcc -c -I. -s -O2 -DWIN32 -DWIN64 -DCONSERVATIVE -DPERL_TEXTMODE_SCRIPTS -DUSE_SITECUSTOMIZE -DPERL_IMPLICIT_CONTEXT -DPERL_IMPLICIT_SYS -DUSE_PERLIO -fno-strict-aliasing -mms-bitfields -s -O2 -DVERSION=\"1.27\" -DXS_VERSION=\"1.27\" "-IC:\Perl64-5.18\lib\CORE" gram.c
gcc -c -I. -s -O2 -DWIN32 -DWIN64 -DCONSERVATIVE -DPERL_TEXTMODE_SCRIPTS -DUSE_SITECUSTOMIZE -DPERL_IMPLICIT_CONTEXT -DPERL_IMPLICIT_SYS -DUSE_PERLIO -fno-strict-aliasing -mms-bitfields -s -O2 -DVERSION=\"1.27\" -DXS_VERSION=\"1.27\" "-IC:\Perl64-5.18\lib\CORE" handler.c
handler.c: In function 'syck_hdlr_add_anchor':
handler.c:39:41: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
handler.c:52:33: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
handler.c:59:28: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
handler.c:59:42: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
handler.c: In function 'syck_hdlr_remove_anchor':
handler.c:79:28: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
handler.c: In function 'syck_hdlr_get_anchor':
handler.c:89:37: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
handler.c:102:51: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
handler.c:105:48: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
handler.c:105:62: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
gcc -c -I. -s -O2 -DWIN32 -DWIN64 -DCONSERVATIVE -DPERL_TEXTMODE_SCRIPTS -DUSE_SITECUSTOMIZE -DPERL_IMPLICIT_CONTEXT -DPERL_IMPLICIT_SYS -DUSE_PERLIO -fno-strict-aliasing -mms-bitfields -s -O2 -DVERSION=\"1.27\" -DXS_VERSION=\"1.27\" "-IC:\Perl64-5.18\lib\CORE" implicit.c
gcc -c -I. -s -O2 -DWIN32 -DWIN64 -DCONSERVATIVE -DPERL_TEXTMODE_SCRIPTS -DUSE_SITECUSTOMIZE -DPERL_IMPLICIT_CONTEXT -DPERL_IMPLICIT_SYS -DUSE_PERLIO -fno-strict-aliasing -mms-bitfields -s -O2 -DVERSION=\"1.27\" -DXS_VERSION=\"1.27\" "-IC:\Perl64-5.18\lib\CORE" node.c
gcc -c -I. -s -O2 -DWIN32 -DWIN64 -DCONSERVATIVE -DPERL_TEXTMODE_SCRIPTS -DUSE_SITECUSTOMIZE -DPERL_IMPLICIT_CONTEXT -DPERL_IMPLICIT_SYS -DUSE_PERLIO -fno-strict-aliasing -mms-bitfields -s -O2 -DVERSION=\"1.27\" -DXS_VERSION=\"1.27\" "-IC:\Perl64-5.18\lib\CORE" syck_.c
syck_.c: In function 'syck_add_sym':
syck_.c:187:29: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
gcc -c -I. -s -O2 -DWIN32 -DWIN64 -DCONSERVATIVE -DPERL_TEXTMODE_SCRIPTS -DUSE_SITECUSTOMIZE -DPERL_IMPLICIT_CONTEXT -DPERL_IMPLICIT_SYS -DUSE_PERLIO -fno-strict-aliasing -mms-bitfields -s -O2 -DVERSION=\"1.27\" -DXS_VERSION=\"1.27\" "-IC:\Perl64-5.18\lib\CORE" syck_st.c
gcc -c -I. -s -O2 -DWIN32 -DWIN64 -DCONSERVATIVE -DPERL_TEXTMODE_SCRIPTS -DUSE_SITECUSTOMIZE -DPERL_IMPLICIT_CONTEXT -DPERL_IMPLICIT_SYS -DUSE_PERLIO -fno-strict-aliasing -mms-bitfields -s -O2 -DVERSION=\"1.27\" -DXS_VERSION=\"1.27\" "-IC:\Perl64-5.18\lib\CORE" token.c
C:\Perl64-5.18\bin\perl.exe "-Iinc" C:\cpanfly-5.18\var\megalib\ExtUtils\xsubpp -typemap C:\Perl64-5.18\lib\ExtUtils\typemap Syck.xs > Syck.xsc && C:\Perl64-5.18\bin\perl.exe "-Iinc" -MExtUtils::Command -e mv -- Syck.xsc Syck.c
gcc -c -I. -s -O2 -DWIN32 -DWIN64 -DCONSERVATIVE -DPERL_TEXTMODE_SCRIPTS -DUSE_SITECUSTOMIZE -DPERL_IMPLICIT_CONTEXT -DPERL_IMPLICIT_SYS -DUSE_PERLIO -fno-strict-aliasing -mms-bitfields -s -O2 -DVERSION=\"1.27\" -DXS_VERSION=\"1.27\" "-IC:\Perl64-5.18\lib\CORE" Syck.c
In file included from Syck.xs:2:0:
perl_common.h: In function 'perl_syck_bad_anchor_handler':
perl_common.h:71:9: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_common.h:72:9: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
In file included from Syck.xs:5:0:
perl_syck.h: In function 'json_syck_mark_emitter':
perl_syck.h:816:35: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
In file included from Syck.xs:5:0:
perl_syck.h:832:31: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:872:27: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h: In function 'json_syck_emitter_handler':
perl_syck.h:886:34: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
perl_syck.h:971:38: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:1089:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:1092:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:1131:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:1132:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:1144:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:1145:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h: In function 'DumpJSONImpl':
perl_syck.h:1303:25: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
In file included from Syck.xs:8:0:
perl_syck.h: In function 'yaml_syck_parser_handler':
perl_syck.h:551:27: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
perl_syck.h:552:27: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
perl_syck.h: In function 'yaml_syck_mark_emitter':
perl_syck.h:816:35: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
In file included from Syck.xs:8:0:
perl_syck.h: In function 'yaml_syck_emitter_handler':
perl_syck.h:886:34: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
perl_syck.h:979:35: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:994:36: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:995:36: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:1089:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:1092:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:1131:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:1132:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:1144:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h:1145:44: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
perl_syck.h: In function 'DumpYAMLImpl':
perl_syck.h:1303:25: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
C:\Perl64-5.18\bin\perl.exe "-Iinc" -MExtUtils::Mksymlists \
-e "Mksymlists('NAME'=>\"YAML::Syck\", 'DLBASE' => 'Syck', 'DL_FUNCS' => { }, 'FUNCLIST' => [], 'IMPORTS' => { }, 'DL_VARS' => []);"
dlltool --def Syck.def --output-exp dll.exp
g++ -o blib\arch\auto\YAML\Syck\Syck.dll -Wl,--base-file -Wl,dll.base -mdll -s -static-libgcc -static-libstdc++ -L"C:\Perl64-5.18\lib\CORE" -L"C:\MinGW\x86_64-w64-mingw32\lib" bytecode.o emitter.o gram.o handler.o implicit.o node.o syck_.o syck_st.o token.o Syck.o C:\Perl64-5.18\lib\CORE\libperl518.a -lmoldname -lkernel32 -luser32 -lgdi32 -lwinspool -lcomdlg32 -ladvapi32 -lshell32 -lole32 -loleaut32 -lnetapi32 -luuid -lws2_32 -lmpr -lwinmm -lversion -lodbc32 -lodbccp32 -lcomctl32 dll.exp
dlltool --def Syck.def --base-file dll.base --output-exp dll.exp
g++ -o blib\arch\auto\YAML\Syck\Syck.dll -mdll -s -static-libgcc -static-libstdc++ -L"C:\Perl64-5.18\lib\CORE" -L"C:\MinGW\x86_64-w64-mingw32\lib" bytecode.o emitter.o gram.o handler.o implicit.o node.o syck_.o syck_st.o token.o Syck.o C:\Perl64-5.18\lib\CORE\libperl518.a -lmoldname -lkernel32 -luser32 -lgdi32 -lwinspool -lcomdlg32 -ladvapi32 -lshell32 -lole32 -loleaut32 -lnetapi32 -luuid -lws2_32 -lmpr -lwinmm -lversion -lodbc32 -lodbccp32 -lcomctl32 dll.exp
C:\Perl64-5.18\bin\perl.exe "-Iinc" -MExtUtils::Command -e chmod -- 755 blib\arch\auto\YAML\Syck\Syck.dll
TODDR/YAML-Syck-1.27.tar.gz
dmake -- OK
Running make test
>>> dmake test TEST_VERBOSE=1
C:\Perl64-5.18\bin\perl.exe "-MExtUtils::Command::MM" "-MTest::Harness" "-e" "undef *Test::Harness::Switches; test_harness(1, 'inc', 'blib\lib', 'blib\arch')" t/*.t t/*/*.t
t/1-basic.t ...................
1..11
ok 1
ok 2
ok 3
not ok 4 - Bad data dies on Load # TODO RT 34073 - Parsing YAML without separator
# Failed (TODO) test 'Bad data dies on Load'
# at t/1-basic.t line 14.
# got: ''
# expected: anything else
not ok 5 - Bad data fails load # TODO RT 34073 - Parsing YAML without separator
# Failed (TODO) test 'Bad data fails load'
# at t/1-basic.t line 15.
# got: '--'
# expected: undef
ok 6 - Bad data fails load
not ok 7 - Bad data dies on Load # TODO Load fails on empty string
# Failed (TODO) test 'Bad data dies on Load'
# at t/1-basic.t line 23.
# got: ''
# expected: anything else
not ok 8 - Bad data dies on Load # TODO Load fails on empty string
# Failed (TODO) test 'Bad data dies on Load'
# at t/1-basic.t line 30.
# got: ''
# expected: anything else
not ok 9 - Bad data fails load # TODO Load fails on empty string
# Failed (TODO) test 'Bad data fails load'
# at t/1-basic.t line 31.
# got: 'feefifofum
#
# dkjdkdk'
# expected: undef
not ok 10 - Bad data dies on Load # TODO RT 23850 - META.yml of DMAKI/DateTime-Format-Japanese-0.01.tar.gz cannot be parsed
# Failed (TODO) test 'Bad data dies on Load'
# at t/1-basic.t line 38.
# got: 'Syck parser (line 3, column -1): syntax error at t/1-basic.t line 35.
# '
# expected: ''
not ok 11 - Bad data fails load # TODO RT 23850 - META.yml of DMAKI/DateTime-Format-Japanese-0.01.tar.gz cannot be parsed
# Failed (TODO) test 'Bad data fails load'
# at t/1-basic.t line 39.
# Structures begin differing at:
# $got = undef
# $expected = ARRAY(0x4f72e8)
ok
t/11-loadfile.t ...............
1..12
ok 1 - LoadFile(*DATA) works
ok 2 - LoadFile(\*DATA) works
ok 3 - LoadFile works with file names
ok 4 - LoadFile works with IO::File
ok 5 - LoadFile works with indirect filehandles
ok 6 - LoadFile works with ordinary filehandles
ok 7 - LoadFile works with glob refs
ok 8 - LoadFile works with in-memory files
ok 9 - LoadFile dies loading an empty file
ok 10 - LoadFile returns undef loading an empty file
ok 11 - No failure reading an empty file handle
ok 12 - LoadFile returns undef loading an empty file
ok
t/12-dumpfile.t ...............
1..6
ok 1 - DumpFile works with filenames
ok 2 - DumpFile works with IO::File
ok 3 - DumpFile works with indirect file handles
ok 4 - DumpFile works with ordinary file handles
ok 5 - DumpFile works with glob refs
ok 6 - DumpFile works with in-memory files
ok
t/2-scalars.t .................
1..134
ok 1 - YAML::Syck has a version and is loaded
ok 2 - Dump a simple number
ok 3 - Load a simple number
ok 4 - A pointer to 42 dumps
ok 5 - A pointer to 42 loads
ok 6 - A Circular Reference Loads.
ok 7 - A Circular Reference Round Trips.
ok 8
ok 9
ok 10
ok 11
ok 12
ok 13
ok 14
ok 15
ok 16
ok 17
ok 18
ok 19
ok 20 - no error
ok 21
ok 22 - no error
ok 23
ok 24
ok 25
ok 26
ok 27
ok 28
ok 29
ok 30
ok 31
ok 32
ok 33
ok 34
ok 35
ok 36
ok 37
ok 38
ok 39
ok 40
ok 41
ok 42
ok 43
ok 44
ok 45
ok 46
ok 47
ok 48 - recurse 1
ok 49 - recurse 2
ok 50
ok 51
ok 52
ok 53
ok 54
ok 55
ok 56
ok 57
ok 58
ok 59
ok 60
ok 61
ok 62
ok 63
ok 64
ok 65
ok 66
ok 67
ok 68
ok 69
ok 70
ok 71
ok 72
ok 73
ok 74
ok 75
ok 76
ok 77
ok 78
ok 79
ok 80
ok 81
ok 82
ok 83
ok 84
ok 85
ok 86
ok 87
ok 88
not ok 89 - HASH(0x26138b8) # TODO roundtrip is breaking for this right now: '---
# ... X: ''
# '
# Failed (TODO) test 'HASH(0x26138b8)'
# at t/2-scalars.t line 243.
# got: undef
# expected: 'HASH(0x2613b58)'
ok 90 - RT 47944 - back quote is a reserved character
ok 91
ok 92
ok 93
ok 94
ok 95
ok 96
ok 97
ok 98
ok 99
ok 100
ok 101
ok 102
ok 103
ok 104
ok 105
ok 106
ok 107
ok 108
ok 109
ok 110
ok 111
ok 112
ok 113
ok 114
ok 115
ok 116
ok 117
ok 118
ok 119
ok 120
ok 121 - Dumped version of file is unquoted
ok 122 - Dumped version of file is unquoted
ok 123 - Dumped version of file is unquoted
ok 124 - Dumped version of file is unquoted
ok 125 - Dumped version of file is unquoted
ok 126 - Dumped version of file is unquoted
ok 127 - Dumped version of file is unquoted
ok 128 - hex Dump preserves as string
ok 129 - hex Load preserves as string
ok 130 - oct Dump preserves by quoting
ok 131 - oct Load preserves by quoting
ok 132 - 00 Dump preserves by quoting
ok 133 - 00 Load preserves by quoting
not ok 134 - RT 54780 - Wrong loading of YAML with double quoted style # TODO not handling double quoted style right
# Failed (TODO) test 'RT 54780 - Wrong loading of YAML with double quoted style'
# at t/2-scalars.t line 286.
# got: 'content\ string
# other\ content
# \
# new
# '
# expected: 'content string
# other content
#
# new
# '
ok
t/3-objects.t .................
1..51
ok 1
ok 2
ok 3 - ref - !!perl/hash:foo
ok 4 - data - !!perl/hash:foo
ok 5 - ref - !perl/foo
ok 6 - data - !perl/foo
ok 7 - ref - !hs/Foo
ok 8 - data - !hs/Foo
ok 9 - ref - !haskell.org/Foo
ok 10 - data - !haskell.org/Foo
ok 11 - ref - !haskell.org/^Foo
ok 12 - data - !haskell.org/^Foo
ok 13 - ref - !!perl
ok 14 - data - !!perl
ok 15 - ref - !!moose
ok 16 - data - !!moose
ok 17 - ref - !ruby/object:Test::Bear
ok 18 - data - !ruby/object:Test::Bear
ok 19 - Testing regexes with the >=5.13.5 caret syntax
ok 20
ok 21
ok 22
ok 23
ok 24
ok 25
ok 26
ok 27 - blessed to code
ok 28 - it's a hash
ok 29 - blessed to foobar
ok 30 - it's a CODE
ok 31 - blessed to code
ok 32 - it's a CODE
ok 33 - ref - !!perl/hash:foo
ok 34 - data - !!perl/hash:foo
ok 35 - ref - !perl/foo
ok 36 - data - !perl/foo
ok 37 - ref - !hs/Foo
ok 38 - data - !hs/Foo
ok 39 - ref - !haskell.org/Foo
ok 40 - data - !haskell.org/Foo
ok 41 - ref - !haskell.org/^Foo
ok 42 - data - !haskell.org/^Foo
ok 43 - ref - !!perl
ok 44 - data - !!perl
ok 45 - ref - !!moose
ok 46 - data - !!moose
ok 47 - ref - !ruby/object:Test::Bear
ok 48 - data - !ruby/object:Test::Bear
ok 49 - Deep hash round trips
ok 50 - Deep hash round trips and strip blessings
ok 51 - Deep hash round trips and doesn't strips blessings
ok
t/4-perl_tag_scheme.t .........
1..18
ok 1
ok 2
ok 3
ok 4
ok 5
ok 6
ok 7
ok 8
ok 9
ok 10
ok 11
ok 12
ok 13
ok 14
ok 15
ok 16
ok 17
ok 18
ok
t/bug/doesnt-stringify.t ......
1..2
ok 1
ok 2
ok
t/bug/rt-49404-double_free.t ..
1..4
ok 1
ok 2
ok 3
ok 4
ok
t/bug/rt-54167.t ..............
1..2
ok 1 - each() iterates properly before YAML::Syck::Dump
ok 2 - each() iterates properly after YAML::Syck::Dump
ok
t/json-basic.t ................
1..104
ok 1 - roundtrip "foo" -> 'foo' -> "foo" -> sq:0 utf8:0
ok 2 - roundtrip "foo" -> 'foo' -> "foo" -> sq:0 utf8:1
ok 3 - roundtrip 'foo' -> 'foo' -> 'foo' -> sq:1 utf8:0
ok 4 - roundtrip 'foo' -> 'foo' -> 'foo' -> sq:1 utf8:1
ok 5 - roundtrip [1,2,3] -> [1,2,3] -> [1,2,3] -> sq:0 utf8:0
ok 6 - roundtrip [1,2,3] -> [1,2,3] -> [1,2,3] -> sq:0 utf8:1
ok 7 - roundtrip [1,2,3] -> [1,2,3] -> [1,2,3] -> sq:1 utf8:0
ok 8 - roundtrip [1,2,3] -> [1,2,3] -> [1,2,3] -> sq:1 utf8:1
ok 9 - roundtrip [1,2,3] -> [1,2,3] -> [1,2,3] -> sq:0 utf8:0
ok 10 - roundtrip [1,2,3] -> [1,2,3] -> [1,2,3] -> sq:0 utf8:1
ok 11 - roundtrip [1,2,3] -> [1,2,3] -> [1,2,3] -> sq:1 utf8:0
ok 12 - roundtrip [1,2,3] -> [1,2,3] -> [1,2,3] -> sq:1 utf8:1
ok 13 - roundtrip 2 -> 2 -> 2 -> sq:0 utf8:0
ok 14 - roundtrip 2 -> 2 -> 2 -> sq:0 utf8:1
ok 15 - roundtrip 2 -> 2 -> 2 -> sq:1 utf8:0
ok 16 - roundtrip 2 -> 2 -> 2 -> sq:1 utf8:1
ok 17 - roundtrip "foo'bar" -> 'foo\'bar' -> "foo'bar" -> sq:0 utf8:0
ok 18 - roundtrip "foo'bar" -> 'foo\'bar' -> "foo'bar" -> sq:0 utf8:1
ok 19 - roundtrip 'foo\'bar' -> 'foo\'bar' -> 'foo\'bar' -> sq:1 utf8:0
ok 20 - roundtrip 'foo\'bar' -> 'foo\'bar' -> 'foo\'bar' -> sq:1 utf8:1
ok 21 - roundtrip [1,2,3] -> [1,2,3] -> [1,2,3] -> sq:0 utf8:0
ok 22 - roundtrip [1,2,3] -> [1,2,3] -> [1,2,3] -> sq:0 utf8:1
ok 23 - roundtrip [1,2,3] -> [1,2,3] -> [1,2,3] -> sq:1 utf8:0
ok 24 - roundtrip [1,2,3] -> [1,2,3] -> [1,2,3] -> sq:1 utf8:1
ok 25 - roundtrip {"foo":"bar"} -> {'foo' => 'bar'} -> {"foo":"bar"} -> sq:0 utf8:0
ok 26 - roundtrip {"foo":"bar"} -> {'foo' => 'bar'} -> {"foo":"bar"} -> sq:0 utf8:1
ok 27 - roundtrip {'foo':'bar'} -> {'foo' => 'bar'} -> {'foo':'bar'} -> sq:1 utf8:0
ok 28 - roundtrip {'foo':'bar'} -> {'foo' => 'bar'} -> {'foo':'bar'} -> sq:1 utf8:1
ok 29 - roundtrip {"foo":"bar"} -> {'foo' => 'bar'} -> {"foo":"bar"} -> sq:0 utf8:0
ok 30 - roundtrip {"foo":"bar"} -> {'foo' => 'bar'} -> {"foo":"bar"} -> sq:0 utf8:1
ok 31 - roundtrip {'foo':'bar'} -> {'foo' => 'bar'} -> {'foo':'bar'} -> sq:1 utf8:0
ok 32 - roundtrip {'foo':'bar'} -> {'foo' => 'bar'} -> {'foo':'bar'} -> sq:1 utf8:1
ok 33 - roundtrip [{"foo":2},{"foo":"bar"}] -> [{'foo' => 2},{'foo' => 'bar'}] -> [{"foo":2},{"foo":"bar"}] -> sq:0 utf8:0
ok 34 - roundtrip [{"foo":2},{"foo":"bar"}] -> [{'foo' => 2},{'foo' => 'bar'}] -> [{"foo":2},{"foo":"bar"}] -> sq:0 utf8:1
ok 35 - roundtrip [{'foo':2},{'foo':'bar'}] -> [{'foo' => 2},{'foo' => 'bar'}] -> [{'foo':2},{'foo':'bar'}] -> sq:1 utf8:0
ok 36 - roundtrip [{'foo':2},{'foo':'bar'}] -> [{'foo' => 2},{'foo' => 'bar'}] -> [{'foo':2},{'foo':'bar'}] -> sq:1 utf8:1
ok 37 - roundtrip "媾" -> '媾' -> "媾" -> sq:0 utf8:0
ok 38 - roundtrip "媾" -> "\x{5abe}" -> "媾" -> sq:0 utf8:1
ok 39 - roundtrip '媾' -> '媾' -> '媾' -> sq:1 utf8:0
ok 40 - roundtrip '媾' -> "\x{5abe}" -> '媾' -> sq:1 utf8:1
ok 41 - roundtrip null -> undef -> null -> sq:0 utf8:0
ok 42 - roundtrip null -> undef -> null -> sq:0 utf8:1
ok 43 - roundtrip null -> undef -> null -> sq:1 utf8:0
ok 44 - roundtrip null -> undef -> null -> sq:1 utf8:1
ok 45 - roundtrip {"foo":null} -> {'foo' => undef} -> {"foo":null} -> sq:0 utf8:0
ok 46 - roundtrip {"foo":null} -> {'foo' => undef} -> {"foo":null} -> sq:0 utf8:1
ok 47 - roundtrip {'foo':null} -> {'foo' => undef} -> {'foo':null} -> sq:1 utf8:0
ok 48 - roundtrip {'foo':null} -> {'foo' => undef} -> {'foo':null} -> sq:1 utf8:1
ok 49 - roundtrip "" -> '' -> "" -> sq:0 utf8:0
ok 50 - roundtrip "" -> '' -> "" -> sq:0 utf8:1
ok 51 - roundtrip '' -> '' -> '' -> sq:1 utf8:0
ok 52 - roundtrip '' -> '' -> '' -> sq:1 utf8:1
ok 53 - roundtrip [null,null] -> [undef,undef] -> [null,null] -> sq:0 utf8:0
ok 54 - roundtrip [null,null] -> [undef,undef] -> [null,null] -> sq:0 utf8:1
ok 55 - roundtrip [null,null] -> [undef,undef] -> [null,null] -> sq:1 utf8:0
ok 56 - roundtrip [null,null] -> [undef,undef] -> [null,null] -> sq:1 utf8:1
ok 57 - roundtrip ["",null] -> ['',undef] -> ["",null] -> sq:0 utf8:0
ok 58 - roundtrip ["",null] -> ['',undef] -> ["",null] -> sq:0 utf8:1
ok 59 - roundtrip ['',null] -> ['',undef] -> ['',null] -> sq:1 utf8:0
ok 60 - roundtrip ['',null] -> ['',undef] -> ['',null] -> sq:1 utf8:1
ok 61 - roundtrip {"foo":""} -> {'foo' => ''} -> {"foo":""} -> sq:0 utf8:0
ok 62 - roundtrip {"foo":""} -> {'foo' => ''} -> {"foo":""} -> sq:0 utf8:1
ok 63 - roundtrip {'foo':''} -> {'foo' => ''} -> {'foo':''} -> sq:1 utf8:0
ok 64 - roundtrip {'foo':''} -> {'foo' => ''} -> {'foo':''} -> sq:1 utf8:1
ok 65 - roundtrip ["\"://\""] -> ['"://"'] -> ["\"://\""] -> sq:0 utf8:0
ok 66 - roundtrip ["\"://\""] -> ['"://"'] -> ["\"://\""] -> sq:0 utf8:1
ok 67 - roundtrip ['\'://\''] -> ['\'://\''] -> ['\'://\''] -> sq:1 utf8:0
ok 68 - roundtrip ['\'://\''] -> ['\'://\''] -> ['\'://\''] -> sq:1 utf8:1
ok 69 - roundtrip "~foo" -> '~foo' -> "~foo" -> sq:0 utf8:0
ok 70 - roundtrip "~foo" -> '~foo' -> "~foo" -> sq:0 utf8:1
ok 71 - roundtrip '~foo' -> '~foo' -> '~foo' -> sq:1 utf8:0
ok 72 - roundtrip '~foo' -> '~foo' -> '~foo' -> sq:1 utf8:1
not ok 73 - roundtrip "\/" -> '\\/' -> "\\/" -> sq:0 utf8:0 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip "\/" -> '\\/' -> "\\/" -> sq:0 utf8:0 '
# at t/json-basic.t line 89.
# got: '"\\/"'
# expected: '"\/"'
not ok 74 - roundtrip "\/" -> '\\/' -> "\\/" -> sq:0 utf8:1 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip "\/" -> '\\/' -> "\\/" -> sq:0 utf8:1 '
# at t/json-basic.t line 89.
# got: '"\\/"'
# expected: '"\/"'
not ok 75 - roundtrip '\/' -> '\\/' -> '\\/' -> sq:1 utf8:0 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\/' -> '\\/' -> '\\/' -> sq:1 utf8:0 '
# at t/json-basic.t line 89.
# got: ''\\/''
# expected: ''\/''
not ok 76 - roundtrip '\/' -> '\\/' -> '\\/' -> sq:1 utf8:1 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\/' -> '\\/' -> '\\/' -> sq:1 utf8:1 '
# at t/json-basic.t line 89.
# got: ''\\/''
# expected: ''\/''
ok 77 - roundtrip "\"" -> '"' -> "\"" -> sq:0 utf8:0
ok 78 - roundtrip "\"" -> '"' -> "\"" -> sq:0 utf8:1
ok 79 - roundtrip '\'' -> '\'' -> '\'' -> sq:1 utf8:0
ok 80 - roundtrip '\'' -> '\'' -> '\'' -> sq:1 utf8:1
ok 81 - roundtrip "\b" -> '' -> "\b" -> sq:0 utf8:0 # TODO backslashed char not working yet
ok 82 - roundtrip "\b" -> '' -> "\b" -> sq:0 utf8:1 # TODO backslashed char not working yet
not ok 83 - roundtrip '\b' -> '\\b' -> '\\b' -> sq:1 utf8:0 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\b' -> '\\b' -> '\\b' -> sq:1 utf8:0 '
# at t/json-basic.t line 89.
# got: ''\\b''
# expected: ''\b''
not ok 84 - roundtrip '\b' -> '\\b' -> '\\b' -> sq:1 utf8:1 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\b' -> '\\b' -> '\\b' -> sq:1 utf8:1 '
# at t/json-basic.t line 89.
# got: ''\\b''
# expected: ''\b''
ok 85 - roundtrip "\f" -> '' -> "\f" -> sq:0 utf8:0 # TODO backslashed char not working yet
ok 86 - roundtrip "\f" -> '' -> "\f" -> sq:0 utf8:1 # TODO backslashed char not working yet
not ok 87 - roundtrip '\f' -> '\\f' -> '\\f' -> sq:1 utf8:0 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\f' -> '\\f' -> '\\f' -> sq:1 utf8:0 '
# at t/json-basic.t line 89.
# got: ''\\f''
# expected: ''\f''
not ok 88 - roundtrip '\f' -> '\\f' -> '\\f' -> sq:1 utf8:1 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\f' -> '\\f' -> '\\f' -> sq:1 utf8:1 '
# at t/json-basic.t line 89.
# got: ''\\f''
# expected: ''\f''
ok 89 - roundtrip "\n" -> '
# ' -> "\n" -> sq:0 utf8:0 # TODO backslashed char not working yet
ok 90 - roundtrip "\n" -> '
# ' -> "\n" -> sq:0 utf8:1 # TODO backslashed char not working yet
not ok 91 - roundtrip '\n' -> '\\n' -> '\\n' -> sq:1 utf8:0 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\n' -> '\\n' -> '\\n' -> sq:1 utf8:0 '
# at t/json-basic.t line 89.
# got: ''\\n''
# expected: ''\n''
not ok 92 - roundtrip '\n' -> '\\n' -> '\\n' -> sq:1 utf8:1 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\n' -> '\\n' -> '\\n' -> sq:1 utf8:1 '
# at t/json-basic.t line 89.
# got: ''\\n''
# expected: ''\n''
ok 93 - roundtrip "\r" -> '
' -> "\r" -> sq:0 utf8:0 # TODO backslashed char not working yet
ok 94 - roundtrip "\r" -> '
' -> "\r" -> sq:0 utf8:1 # TODO backslashed char not working yet
not ok 95 - roundtrip '\r' -> '\\r' -> '\\r' -> sq:1 utf8:0 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\r' -> '\\r' -> '\\r' -> sq:1 utf8:0 '
# at t/json-basic.t line 89.
# got: ''\\r''
# expected: ''\r''
not ok 96 - roundtrip '\r' -> '\\r' -> '\\r' -> sq:1 utf8:1 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\r' -> '\\r' -> '\\r' -> sq:1 utf8:1 '
# at t/json-basic.t line 89.
# got: ''\\r''
# expected: ''\r''
ok 97 - roundtrip "\t" -> ' ' -> "\t" -> sq:0 utf8:0 # TODO backslashed char not working yet
ok 98 - roundtrip "\t" -> ' ' -> "\t" -> sq:0 utf8:1 # TODO backslashed char not working yet
not ok 99 - roundtrip '\t' -> '\\t' -> '\\t' -> sq:1 utf8:0 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\t' -> '\\t' -> '\\t' -> sq:1 utf8:0 '
# at t/json-basic.t line 89.
# got: ''\\t''
# expected: ''\t''
not ok 100 - roundtrip '\t' -> '\\t' -> '\\t' -> sq:1 utf8:1 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\t' -> '\\t' -> '\\t' -> sq:1 utf8:1 '
# at t/json-basic.t line 89.
# got: ''\\t''
# expected: ''\t''
not ok 101 - roundtrip "\u0001" -> '\\u0001' -> "\\u0001" -> sq:0 utf8:0 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip "\u0001" -> '\\u0001' -> "\\u0001" -> sq:0 utf8:0 '
# at t/json-basic.t line 89.
# got: '"\\u0001"'
# expected: '"\u0001"'
not ok 102 - roundtrip "\u0001" -> '\\u0001' -> "\\u0001" -> sq:0 utf8:1 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip "\u0001" -> '\\u0001' -> "\\u0001" -> sq:0 utf8:1 '
# at t/json-basic.t line 89.
# got: '"\\u0001"'
# expected: '"\u0001"'
not ok 103 - roundtrip '\u0001' -> '\\u0001' -> '\\u0001' -> sq:1 utf8:0 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\u0001' -> '\\u0001' -> '\\u0001' -> sq:1 utf8:0 '
# at t/json-basic.t line 89.
# got: ''\\u0001''
# expected: ''\u0001''
not ok 104 - roundtrip '\u0001' -> '\\u0001' -> '\\u0001' -> sq:1 utf8:1 # TODO backslashed char not working yet
# Failed (TODO) test 'roundtrip '\u0001' -> '\\u0001' -> '\\u0001' -> sq:1 utf8:1 '
# at t/json-basic.t line 89.
# got: ''\\u0001''
# expected: ''\u0001''
ok
Timeout (max run time is 300s)
C:\Perl64-5.18\bin\perl.exe exits with 37.