NAME

       Test::Synopsis::Expectation - Test that SYNOPSIS code produces expected results

SYNOPSIS

           use Test::Synopsis::Expectation;

           synopsis_ok('eg/sample.pod');
           done_testing;

       Following, SYNOPSIS of eg/sample.pod

           my $num;
           $num = 1; # => 1
           ++$num;   # => is 2

           use PPI::Tokenizer;
           my $tokenizer = PPI::Tokenizer->new(\'code'); # => isa 'PPI::Tokenizer'

           my $str = 'Hello, I love you'; # => like qr/ove/

           my $obj = {
               foo => ["bar", "baz"],
           }; # => is_deeply { foo => ["bar", "baz"] }

           my $bool = 1; # => success

DESCRIPTION

       This module checks that a module's SYNOPSIS section is syntactically correct, and will
       also check that it produces the expected results, based on annotations you add in
       comments.

FUNCTIONS

       •   synopsis_ok($files)

           This function tests SYNOPSIS codes of each files.  This function expects file names as
           an argument as ARRAYREF or SCALAR.  (This function is exported)

       •   all_synopsis_ok()

           This function tests SYNOPSIS codes of the all of library files.  This function uses
           MANIFEST to list up the target files of testing.  (This function is exported)

       •   prepare($code_str)

           Register the executable codes to prepare for evaluation.

           If you use like;

               use Test::Synopsis::Expectation;
               Test::Synopsis::Expectation::prepare('my $foo = 1;');
               synopsis_ok('path/to/target.pm');
               done_testing;

               ### Following, SYNOPSIS of `target.pm`
               $foo; # => 1

           Then, SYNOPSIS of target.pm is the same as;

               my $foo = 1;
               $foo; # => 1

           (This function is not exported)

       •   set_ignorings

           Set the procedures which would like to ignore.

               use Test::Synopsis::Expectation;
               Test::Synopsis::Expectation::set_ignorings(['++$num;']);
               synopsis_ok(*DATA);
               done_testing;

               __DATA__
               =head1 SYNOPSIS

                   my $num;
                   $num = 1; # => 1
                   ++$num;
                   $num; # => 1

           In the above example, "++$num;" will be ignored.

NOTATION OF EXPECTATION

       Comment that starts at "# =>" then this module treats the comment as test statement.

       •   # => is

               my $foo = 1; # => is 1

           This way is equivalent to the next.

               my $foo = 1;
               is $foo, 1;

           This carries out the same behavior as "Test::More::is".

       •   # =>

               my $foo = 1; # => 1

           This notation is the same as "# => is"

       •   # => isa

               use Foo::Bar;
               my $instance = Foo::Bar->new; # => isa 'Foo::Bar'

           This way is equivalent to the next.

               use Foo::Bar;
               my $instance = Foo::Bar->new;
               isa_ok $instance, 'Foo::Bar';

           This carries out the same behavior as "Test::More::isa_ok".

       •   # => like

               my $str = 'Hello, I love you'; # => like qr/ove/

           This way is equivalent to the next.

               my $str = 'Hello, I love you';
               like $str, qr/ove/;

           This carries out the same behavior as "Test::More::like".

       •   # => is_deeply

               my $obj = {
                   foo => ["bar", "baz"],
               }; # => is_deeply { foo => ["bar", "baz"] }

           This way is equivalent to the next.

               my $obj = {
                   foo => ["bar", "baz"],
               };
               is_deeply $obj, { foo => ["bar", "baz"] };

           This carries out the same behavior as "Test::More::is_deeply".

       •   # => success

               my $bool = 1;
               $bool; # => success

           This way checks value as boolean.  If target value of testing is 0 then this test will
           fail. Otherwise, it will pass.

ANNOTATIONS

       •   =for test_synopsis_expectation_no_test

           The code block behind this annotation will not be tested.

                   my $sum;
                   $sum = 1; # => 1

               =for test_synopsis_expectation_no_test

                   my $sum;
                   $sum = 1; # => 2

           In this example, the first code block will be tested, but the second will not.

RESTRICTION

   Test case must be one line
       The following is valid;

           my $obj = {
               foo => ["bar", "baz"],
           }; # => is_deeply { foo => ["bar", "baz"] }

       However, the following is invalid;

           my $obj = {
               foo => ["bar", "baz"],
           }; # => is_deeply {
              #        foo => ["bar", "baz"]
              #    }

       So test case must be one line.

   Not put test cases inside of for(each)
           # Example of not working
           for (1..10) {
               my $foo = $_; # => 10
           }

       This example doesn't work. On the contrary, it will be error (Probably nobody uses such as
       this way... I think).

NOTES

   yada-yada operator
       This module ignores yada-yada operators that is in SYNOPSIS code.  Thus, following code is
       runnable.

           my $foo;
           ...
           $foo = 1; # => 1

SEE ALSO

       Test::Synopsis - simpler module, which just checks the syntax of your SYNOPSIS section.

       Dist::Zilla::Plugin::Test::Synopsis - a plugin for Dist::Zilla users, which adds a release
       test to your distribution, based on Test::Synopsis.

REPOSITORY

       <https://github.com/moznion/Test-Synopsis-Expectation>

LICENSE

       Copyright (C) moznion.

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

AUTHOR

       moznion <moznion@gmail.com>