view release on metacpan or  search on metacpan

t/state/continue.t  view on Meta::CPAN

    { switch => \&AFSMTS_U, uturn  => [ q|RQ|, undef, q|RC| ]}},
                             qr.\Q{RQ}(): record !isa defined .     ],
 [                          q|[_], trailing noise|,
  [qw|                            shift eignore |],
  { CONTINUE  =>
    { switch =>                       \&AFSMTS_T,
      turns  => { 1 => [ q|BJ|, undef, q|MF| ]}} },
                qr.\Q{BJ}(): record !isa defined .                  ],
 [                   q|(CONTINUE/noise)|,
  [qw|                                |],
  { CONTINUE =>
    { eturn => [ ],
      uturn => [ ],
      tturn => [ ],
      fturn => [ ],
      turns => { } }                   },
  qr.\Q{CONTINUE}{switch} !isa defined .                            ],
 [                   q|[T](CONTINUE/noise)|,
  [qw| shift                             |],
  { CONTINUE  =>
    { switch =>          \&AFSMTS_T,
      eturn  => [qw| CONTINUE JR |],
      tturn  => [qw| CONTINUE EL |] }     },
  [ qr.\Q{CONTINUE}(JR): unknown action .,
    qr.\Q{CONTINUE}(EL): unknown action . ]                         ],
 [                                  q|[F](CONTINUE/noise)|,
  [qw|                                    shift eignore |],
  { CONTINUE  =>
    { switch => \&AFSMTS_F, fturn => [qw| CONTINUE MB |]}},
                     qr.\Q{CONTINUE}(MB): unknown action .          ],
 [                                  q|[U](CONTINUE/noise)|,
  [qw|                                    shift eignore |],
  { CONTINUE  =>
    { switch => \&AFSMTS_U, uturn => [qw| CONTINUE GP |]}},
                     qr.\Q{CONTINUE}(GP): unknown action .          ],
 [                                           q|[_](CONTINUEnoise)|,
  [qw|                                            shift eignore |],
  { CONTINUE  =>
    { switch => \&AFSMTS_T, turns => { 1 => [qw| CONTINUE HC |]}}},
                             qr.\Q{CONTINUE}(HC): unknown action .  ],
 [                 q|[T](CONTINUE/NEXT)|,
  [qw|                           todo |],
  { CONTINUE  =>
    { switch =>            \&AFSMTS_T,
      eturn  => [qw| CONTINUE NEXT |],
      tturn  => [qw| CONTINUE NEXT |] }}                            ],
 [                                     q|[F](CONTINUE/NEXT)|,
  [qw|                                       todo eignore |],
  { CONTINUE  =>
    { switch => \&AFSMTS_F, fturn => [qw| CONTINUE NEXT |]}}        ],
 [                                     q|[U](CONTINUE/NEXT)|,
  [qw|                                       todo eignore |],
  { CONTINUE  =>
    { switch => \&AFSMTS_U, uturn => [qw| CONTINUE NEXT |]}}        ],
 [                         q|[_](CONTINUE/NEXT)|,
  [qw|                           todo eignore |],
  { CONTINUE  =>
    { switch =>                     \&AFSMTS_T,
      turns  => { 1 => [qw| CONTINUE NEXT |]}} }                    ] );

plan tests => 2 + scalar map {
    ( '' ) x ( 2 - grep( q|eignore| eq $_, @{$_->[1]})) } @data;

%st =
( START    => { switch => sub { 1 }, tturn => [qw| workload |]},
  workload =>
  { switch  =>              \&AFSMTS_T,
    eturn   => [qw| BREAK    bodine |],
    tturn   => [qw| BREAK godolphin |]                        },
  BREAK    => {                          switch => \&AFSMTS_T } );
AFSMTS_wrap;
AFSMTS_deeply @{[[qw| bodine |], { %common, action => q|bodine| }]},
  qq|FST sample consumes empty|;
toggle_now;
AFSMTS_wrap;
AFSMTS_deeply
@{[[qw|                                                  godolphin |],
   { %common, action => q|godolphin|, queue => [ q|mannaro|, undef ]} ]},
  qq|FST sample consumes one|;

foreach my $item ( @data ) {
    $st{$_} = $item->[2]{$_}                       foreach keys %{$item->[2]};
    if( grep q|todo| eq $_, @{$item->[1]} )       {
        local $TODO = q|should detect|;
        combo_now;
        unlike $@, qr.^ALRM., qq|empty, $item->[0]|                     unless
          grep $_ eq q|eignore|, @{$item->[1]};
        combo_now;
        unlike $@, qr.^ALRM., qq|full, $item->[0]| }
    else                                          {
        my $res = ref $item->[3] eq q|ARRAY| ?
                                  $item->[3] : [ $item->[3], $item->[3] ];
        combo_now;
        is_deeply [                 $@ =~ $res->[0], scalar @input ],
        [ !0, scalar( grep q|shift| eq $_, @{$item->[1]} ) ? 3 : 4 ],
          AFSMTS_croakson qq|empty, $item->[0]|                         unless
          grep $_ eq q|eignore|, @{$item->[1]};
        combo_now;
        is_deeply [                 $@ =~ $res->[1], scalar @input ],
        [ !0, scalar( grep q|shift| eq $_, @{$item->[1]} ) ? 3 : 4 ],
          AFSMTS_croakson qq|full, $item->[0]|     }
    @input = @inbase        }

# vim: set filetype=perl