view release on metacpan or  search on metacpan

t/base/query_switch.t  view on Meta::CPAN

  [qw|                                  pass |],
  sub {                    sub { undef }, { } },
  [                                           ],
  sub {                                   $rc },
  [qw|                                 uturn |]                       ],
 [q|{turns}, {switch} returns explicit (undef), argument is set|,
  [qw|                                                   pass |],
  sub {                                     sub { undef }, { } },
  [qw|                                              clearcase |],
  sub {                                                    $rc },
  [qw|                                                  uturn |]      ],
 [q|{turns}, {switch} returns empty string|,
  [qw|                              pass |],
  sub {                   sub { '' }, { } },
  [                                       ],
  sub {                               $rc },
  [qw|                             turn% |],                          ],
 [q|{turns}, {switch} returns empty string, argument is set|,
  [qw|                                               pass |],
  sub {                                    sub { '' }, { } },
  [qw|                             team_foundation_server |],
  sub {                                                $rc },
  [qw|                                              turn% |]          ],
 [q|{turns}, {switch} returns nil|,
  [qw|                     pass |],
  sub {           sub { 0 }, { } },
  [                              ],
  sub {                      $rc },
  [qw|                   turn%0 |]                                    ],
 [q|{turns}, {switch} returns nil, argument is set|,
  [qw|                                      pass |],
  sub {                            sub { 0 }, { } },
  [qw|                                    siveco |],
  sub {                                       $rc },
  [qw|                                    turn%0 |]                   ],
 [q|{turns}, {switch} returns one item|,
  [qw|                          pass |],
  sub {       sub { q|opencvs| }, { } },
  [                                   ],
  sub {                           $rc },
  [qw|                  turn%opencvs |]                               ],
 [q|{turns}, {switch} returns one item, argument is set|,
  [qw|                                           pass |],
  sub {                        sub { q|opencvs| }, { } },
  [qw|                                       Perforce |],
  sub {                                            $rc },
  [qw|                                   turn%opencvs |]              ],
 [        q|{turns}, {switch} returns two items|,
  [qw|                                   pass |],
  sub { sub { qw| bitkeeper evolution | }, { } },
  [                                            ],
  sub {                                    $rc },
  [qw|                         turn%bitkeeper |]                      ],
 [q|{turns}, {switch} returns two items, argument is set|,
  [qw|                                            pass |],
  sub {          sub { qw| bitkeeper evolution | }, { } },
  [qw|                                            sccs |],
  sub {                                            @$rc },
  [qw|                        turn%bitkeeper evolution |]             ] );

plan tests => sum map          {
  ( grep( $_ eq q|pass|, @$_ ) ? 1 :
    grep( $_ eq q|fail|, @$_ ) ? 1 : 0 ) +
    grep( $_ eq q|noise|, @$_ ) }
    map {               $_->[1] } @data;

foreach my $unit ( @data )                      {
    my( $lfix, $rfix ) = $unit->[2]->();
    $st{START}{switch} = $lfix // $st{START}{switch};
    if( grep $_ eq q|copy|, @{$unit->[1]} )      {
                    AFSMTS_object_wrap $bb, $rfix }
    else                                         {
        AFSMTS_class_wrap { %plug, %$rfix }, \%st }
    AFSMTS_method_wrap $method, @{$unit->[3]};
    if( grep $_ eq q|pass|, @{$unit->[1]} )    {
        is_deeply [ $unit->[4]->() ], $unit->[5], qq|$unit->[0], queried|;
        grep $_ eq q|noise|, @{$unit->[1]}                            or next;
        like $stderr, $unit->[6]{$_}, qq|$unit->[0], $_|
                     foreach keys %{$unit->[6]} }
    elsif( grep $_ eq q|fail|, @{$unit->[1]} ) {
        like $@, $unit->[4], AFSMTS_croakson qq|$unit->[0], queried|;
        grep $_ eq q|noise|, @{$unit->[1]}                            or next;
        Test::More->can( index( $_, '-' ) ? q|like| : q|unlike| )->
        ( $stderr, $unit->[5]{$_}, qq|$unit->[0], $_| )
                     foreach keys %{$unit->[5]} }}

# vim: set filetype=perl