t/types_moose_2.t

   1 #!perl
   2 use warnings FATAL => 'all';
   3 use strict;
   4
   5 use Test::More
   6         eval { require Moose::Util }
   7         ? (tests => 49)
   8         : (skip_all => "Moose required for testing types")
   9 ;
  10 use Test::Fatal;
  11
  12 use Function::Parameters qw(:strict);
  13
  14 fun foo(('Int') $n, ('CodeRef') $f, $x) {
  15         $x = $f->($x) for 1 .. $n;
  16         $x
  17 }
  18
  19 is foo(0, fun {}, undef), undef;
  20 is foo(0, fun {}, "o hai"), "o hai";
  21 is foo(3, fun ($x) { "($x)" }, 1.5), "(((1.5)))";
  22 is foo(3, fun (('Str') $x) { "($x)" }, 1.5), "(((1.5)))";
  23
  24 {
  25         my $info = Function::Parameters::info \&foo;
  26         is $info->invocant, undef;
  27         is $info->slurpy, undef;
  28         is $info->positional_optional, 0;
  29         is $info->named_required, 0;
  30         is $info->named_optional, 0;
  31         my @req = $info->positional_required;
  32         is @req, 3;
  33         is $req[0]->name, '$n';
  34         ok $req[0]->type->equals('Int');
  35         is $req[1]->name, '$f';
  36         ok $req[1]->type->equals('CodeRef');
  37         is $req[2]->name, '$x';
  38         is $req[2]->type, undef;
  39 }
  40
  41 like exception { foo("ermagerd", fun {}, undef) }, qr/\bparameter 1.+\$n\b.+\bValidation failed\b.+\bInt\b.+ermagerd/;
  42 like exception { foo(0, {}, undef) }, qr/\bparameter 2.+\$f\b.+\bValidation failed\b.+\bCodeRef\b/;
  43
  44 fun bar(
  45         (
  46                 do {
  47                         require Moose;
  48                         (Function::Parameters::info(\&foo)->positional_required)[0]->type
  49                 }
  50         ) $whoa
  51 ) { $whoa * 2 }
  52
  53 is bar(21), 42;
  54 {
  55         my $info = Function::Parameters::info \&bar;
  56         is $info->invocant, undef;
  57         is $info->slurpy, undef;
  58         is $info->positional_optional, 0;
  59         is $info->named_required, 0;
  60         is $info->named_optional, 0;
  61         my @req = $info->positional_required;
  62         is @req, 1;
  63         is $req[0]->name, '$whoa';
  64         ok $req[0]->type->equals('Int');
  65 }
  66
  67 {
  68         my $info = Function::Parameters::info(fun ( (q~ArrayRef [ Int | CodeRef ]~ )@nom) {});
  69         is $info->invocant, undef;
  70         is $info->positional_required, 0;
  71         is $info->positional_optional, 0;
  72         is $info->named_required, 0;
  73         is $info->named_optional, 0;
  74         my $slurpy = $info->slurpy;
  75         is $slurpy->name, '@nom';
  76         ok $slurpy->type->equals(Moose::Util::TypeConstraints::find_or_parse_type_constraint('ArrayRef[Int|CodeRef]'));
  77 }
  78
  79 {
  80         my $phase = 'runtime';
  81         BEGIN { $phase = 'A'; }
  82         fun
  83          baz
  84           (
  85            (
  86             is
  87              (
  88               $phase
  89                ++
  90                 ,
  91                  'A'
  92              )
  93               ,
  94                'Int'
  95            )
  96             :
  97              $marco
  98               ,
  99                (
 100                 is
 101                  (
 102                   $phase
 103                    ++
 104                     ,
 105                      'B'
 106                  )
 107                   ,
 108                    q
 109                     $ArrayRef[Str]$
 110                )
 111                 :
 112                  $polo
 113              )
 114               {
 115                [
 116                 $marco
 117                  ,
 118                   $polo
 119               ]
 120           }
 121         BEGIN { is $phase, 'C'; }
 122         is $phase, 'runtime';
 123
 124         is_deeply baz(polo => [qw(foo bar baz)], marco => 11), [11, [qw(foo bar baz)]];
 125
 126         my $info = Function::Parameters::info \&baz;
 127         is $info->invocant, undef;
 128         is $info->slurpy, undef;
 129         is $info->positional_required, 0;
 130         is $info->positional_optional, 0;
 131         is $info->named_optional, 0;
 132         my @req = $info->named_required;
 133         is @req, 2;
 134         is $req[0]->name, '$marco';
 135         ok $req[0]->type->equals('Int');
 136         is $req[1]->name, '$polo';
 137         ok $req[1]->type->equals('ArrayRef[Str]');
 138 }