++ed by:
POTATOGIM

1 PAUSE user

Magnolia K

NAME

TAP::Tree - TAP (Test Anything Protocol) parser which supported the subtest

SYNOPSIS

Parses a TAP output.

  use v5.10.1;
  require TAP::Tree;
  my $tap = <<'END';
  1..2
      ok 1 - sub test 1
      1..1
  ok 1 - test 1
  not ok 2 - test 2
  END

  my $taptree = TAP::Tree->new( tap_ref => \$tap );
  my $tree = $taptree->parse;   # return value is hash reference simply.

  say $tree->{plan}{number};             # -> print 2
  say $tree->{testline}[0]{description}; # -> print test 1
  say $tree->{testline}[1]{description}; # -> print test 2

  say $tree->{testline}[0]{subtest}{testline}[0]{description};
  # -> print sub test 1

Summarises the parsed TAP output

  my $summary = $taptree->summary;
  say $summary->{planned_tests}; # -> print 2
  say $summary->{ran_tests};     # -> print 2
  say $summary->{failed_tests};  # -> print 1 ... number of failed tests.
                                # 'TODO' tests are counted as 'ok', not 'not ok'

Iterates the parsed TAP

  my $iterator = $taptree->create_tap_tree_iterator( subtest => 1 );
  
  while ( my $result = $iterator->next ) {
      say '>' x $result->{indent} . $result->{testline}{description};
  }

  # -> print
  #   test 1
  #   >sub test 1
  #   test 2

DESCRIPTION

TAP::Tree is a simple parser of TAP which supported the subtest.

It parses the data of a TAP format to the data of tree structure.

Moreover, the iterator for complicated layered tree structure is also prepared.

METHODS

  • new

      require TAP::Tree;
      my $taptree = TAP::Tree->new( tap_ref => $tap_ref );

    Creates the instance of TAP::Tree.

    Specify the reference to the scalar variable which stored the outputs of TAP as tap_ref of an arguments.

    The arguments can be specified tap_file and tap_tree in addition to tap_ref.

    tap_file is specified the path to file which stored the outputs of TAP.

      my $taptree = TAP::Tree->new( tap_file => $path );

    tap_tree is specified the data of the tree structure which TAP::Tree parsed.

      my $taptree = TAP::Tree->new( tap_tree => $parsed_tap );

    utf8 is specified, when TAP is encoded by UTF-8.

      my $taptree = TAP::Tree->new( tap_ref => $tap_ref, utf8 => 1 );
  • parse

      require TAP::Tree;
      my $taptree = TAP::Tree->new( tap_ref => $tap_ref );
      my $tree    = $taptree->parse;
    
      say $tree->{plan}{number};
      say $tree->{testline}[0]->{description};

    Parses a output of TAP and returns the tree structure data. The return value is a hash reference and all of the parsed result of TAP are stored.

    Please dump the detailed content of inclusion :)

      {
          version   => {},  # the version number of TAP (usually 12). 
          plan      => {},  # the hash reference in which the numbers of tests.
          testline  => [],  # the array reference in which the result of each tests.
          bailout   => {},  # the hash reference in which an informational about Bailout.
      }
  • summary

    Returns the summary of the TAP output.

    The contents of a summary is below ( hash reference ).

      version          -> the version number of TAP (usually 12).
      is_skipped_all   -> the flag that shows whether all the tests were skipped.
      skip_all_msg     -> the message that shows the reason of skip tests.
      is_bailout       -> the flag that shows whether bailout the tests.
      bailout_msg      -> the message that shows the reason of bailout.
      planned_tests    -> the number of the planned tests.
      ran_tests        -> the number of the ran tests.
      failed_tests     -> the number of the failed tests.
      is_good_plan     -> the flag that shows whether the number of plan is set.
      is_ran_all_tests -> the flag that shows whether the all tests are ran.
  • create_tap_tree_iterator

    TAP::Tree makes becomes the complicated structure where a hierarchy is deep, when there is a subtest.

    Therefore, the iterator which can follow a tree strucutre data easily is prepared for TAP::Tree.

      my $taptree = TAP::Tree->new( tap_ref => $tap_ref );
      $taptree->parse;
      my $iterator = $taptree->create_tap_tree_iterator( subtest => 1);
    
      my $test = $iterator->next;
      say $test->{testline}{description};

    Specify arguments subtest, when following subtest.

ISSUE REPORT

https://github.com/magnolia-k/p5-TAP-Tree/issues

COPYRIGHT

copyright 2014- Magnolia <magnolia.k@me.com>.

LICENSE

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.