Initial Commit

database/perl/vendor/lib/Test2/Manual/Testing/Introduction.pm

@@ -0,0 +1,293 @@
+package Test2::Manual::Testing::Introduction;
+use strict;
+use warnings;
+
+our $VERSION = '0.000139';
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test2::Manual::Testing::Introduction - Introduction to testing with Test2.
+
+=head1 DESCRIPTION
+
+This tutorial is a beginners introduction to testing. This will take you
+through writing a test file, making assertions, and running your test.
+
+=head1 BOILERPLATE
+
+=head2 THE TEST FILE
+
+Test files typically are placed inside the C<t/> directory, and end with the
+C<.t> file extension.
+
+C<t/example.t>:
+
+    use Test2::V0;
+
+    # Assertions will go here
+
+    done_testing;
+
+This is all the boilerplate you need.
+
+=over 4
+
+=item use Test2::V0;
+
+This loads a collection of testing tools that will be described later in the
+tutorial. This will also turn on C<strict> and C<warnings> for you.
+
+=item done_testing;
+
+This should always be at the end of your test files. This tells L<Test2> that
+you are done making assertions. This is important as C<test2> will assume the
+test did not complete successfully without this, or some other form of test
+"plan".
+
+=back
+
+=head2 DIST CONFIG
+
+You should always list bundles and tools directly. You should not simply list
+L<Test2::Suite> and call it done, bundles and tools may be moved out of
+L<Test2::Suite> to their own dists at any time.
+
+=head3 Dist::Zilla
+
+    [Prereqs / TestRequires]
+    Test2::V0 = 0.000060
+
+=head3 ExtUtils::MakeMaker
+
+    my %WriteMakefileArgs = (
+      ...,
+      "TEST_REQUIRES" => {
+        "Test2::V0" => "0.000060"
+      },
+      ...
+    );
+
+=head3 Module::Install
+
+    test_requires 'Test2::V0' => '0.000060';
+
+=head3 Module::Build
+
+    my $build = Module::Build->new(
+        ...,
+        test_requires => {
+            "Test2::V0" => "0.000060",
+        },
+        ...
+    );
+
+=head1 MAKING ASSERTIONS
+
+The most simple tool for making assertions is C<ok()>. C<ok()> lets you assert
+that a condition is true.
+
+    ok($CONDITION, "Description of the condition");
+
+Here is a complete C<t/example.t>:
+
+    use Test2::V0;
+
+    ok(1, "1 is true, so this will pass");
+
+    done_testing;
+
+=head1 RUNNING THE TEST
+
+Test files are simply scripts. Just like any other script you can run the test
+directly with perl. Another option is to use a test "harness" which runs the
+test for you, and provides extra information and checks the scripts exit value
+for you.
+
+=head2 RUN DIRECTLY
+
+    $ perl -Ilib t/example.t
+
+Which should produce output like this:
+
+    # Seeded srand with seed '20161028' from local date.
+    ok 1 - 1 is true, so this will pass
+    1..1
+
+If the test had failed (C<ok(0, ...)>) it would look like this:
+
+    # Seeded srand with seed '20161028' from local date.
+    not ok 1 - 0 is false, so this will fail
+    1..1
+
+Test2 will also set the exit value of the script, a successful run will have an
+exit value of 0, a failed run will have a non-zero exit value.
+
+=head2 USING YATH
+
+The C<yath> command line tool is provided by L<Test2::Harness> which you may
+need to install yourself from cpan. C<yath> is the harness written specifically
+for L<Test2>.
+
+    $ yath -Ilib t/example.t
+
+This will produce output similar to this:
+
+    ( PASSED )  job  1    t/example.t
+
+    ================================================================================
+
+    Run ID: 1508027909
+
+    All tests were successful!
+
+You can also request verbose output with the C<-v> flag:
+
+    $ yath -Ilib -v t/example.t
+
+Which produces:
+
+    ( LAUNCH )  job  1    example.t
+    (  NOTE  )  job  1    Seeded srand with seed '20171014' from local date.
+    [  PASS  ]  job  1  + 1 is true, so this will pass
+    [  PLAN  ]  job  1    Expected asserions: 1
+    ( PASSED )  job  1    example.t
+
+    ================================================================================
+
+    Run ID: 1508028002
+
+    All tests were successful!
+
+=head2 USING PROVE
+
+The C<prove> command line tool is provided by the L<Test::Harness> module which
+comes with most versions of perl. L<Test::Harness> is dual-life, which means
+you can also install the latest version from cpan.
+
+    $ prove -Ilib t/example.t
+
+This will produce output like this:
+
+    example.t .. ok
+    All tests successful.
+    Files=1, Tests=1,  0 wallclock secs ( 0.01 usr  0.00 sys +  0.05 cusr  0.00 csys =  0.06 CPU)
+    Result: PASS
+
+You can also request verbose output with the C<-v> flag:
+
+    $ prove -Ilib -v t/example.t
+
+The verbose output looks like this:
+
+    example.t ..
+    # Seeded srand with seed '20161028' from local date.
+    ok 1 - 1 is true, so this will pass
+    1..1
+    ok
+    All tests successful.
+    Files=1, Tests=1,  0 wallclock secs ( 0.02 usr  0.00 sys +  0.06 cusr  0.00 csys =  0.08 CPU)
+    Result: PASS
+
+=head1 THE "PLAN"
+
+All tests need a "plan". The job of a plan is to make sure you ran all the
+tests you expected. The plan prevents a passing result from a test that exits
+before all the tests are run.
+
+There are 2 primary ways to set the plan:
+
+=over 4
+
+=item done_testing()
+
+The most common, and recommended way to set a plan is to add C<done_testing> at
+the end of your test file. This will automatically calculate the plan for you
+at the end of the test. If the test were to exit early then C<done_testing>
+would not run and no plan would be found, forcing a failure.
+
+=item plan($COUNT)
+
+The C<plan()> function allows you to specify an exact number of assertions you
+want to run. If you run too many or too few assertions then the plan will not
+match and it will be counted as a failure. The primary problem with this way of
+planning is that you need to add up the number of assertions, and adjust the
+count whenever you update the test file.
+
+C<plan()> must be used before all assertions, or after all assertions, it
+cannot be done in the middle of making assertions.
+
+=back
+
+=head1 ADDITIONAL ASSERTION TOOLS
+
+The L<Test2::V0> bundle provides a lot more than C<ok()>,
+C<plan()>, and C<done_testing()>. The biggest tools to note are:
+
+=over 4
+
+=item is($a, $b, $description)
+
+C<is()> allows you to compare 2 structures and insure they are identical. You
+can use it for simple string comparisons, or even deep data structure
+comparisons.
+
+    is("foo", "foo", "Both strings are identical");
+
+    is(["foo", 1], ["foo", 1], "Both arrays contain the same elements");
+
+=item like($a, $b, $description)
+
+C<like()> is similar to C<is()> except that it only checks items listed on the
+right, it ignores any extra values found on the left.
+
+    like([1, 2, 3, 4], [1, 2, 3], "Passes, the extra element on the left is ignored");
+
+You can also used regular expressions on the right hand side:
+
+    like("foo bar baz", qr/bar/, "The string matches the regex, this passes");
+
+You can also nest the regexes:
+
+    like([1, 2, 'foo bar baz', 3], [1, 2, qr/bar/], "This passes");
+
+=back
+
+=head1 SEE ALSO
+
+L<Test2::Manual> - Primary index of the manual.
+
+=head1 SOURCE
+
+The source code repository for Test2-Manual can be found at
+F<https://github.com/Test-More/Test2-Suite/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2018 Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

database/perl/vendor/lib/Test2/Manual/Testing/Migrating.pm

@@ -0,0 +1,420 @@
+package Test2::Manual::Testing::Migrating;
+use strict;
+use warnings;
+
+our $VERSION = '0.000139';
+
+1;
+
+=head1 NAME
+
+Test2::Manual::Testing::Migrating - How to migrate existing tests from
+Test::More to Test2.
+
+=head1 DESCRIPTION
+
+This tutorial covers the conversion of an existing test. This tutorial assumes
+you have a test written using L<Test::More>.
+
+=head1 LEGACY TEST
+
+This tutorial will be converting this example test one section at a time:
+
+C<t/example.t>:
+
+    #####################
+    # Boilerplate
+
+    use strict;
+    use warnings;
+
+    use Test::More tests => 14;
+
+    use_ok 'Scalar::Util';
+    require_ok 'Exporter';
+
+    #####################
+    # Simple assertions (no changes)
+
+    ok(1, "pass");
+
+    is("apple", "apple", "Simple string compare");
+
+    like("foo bar baz", qr/bar/, "Regex match");
+
+    #####################
+    # Todo
+
+    {
+        local $TODO = "These are todo";
+
+        ok(0, "oops");
+    }
+
+    #####################
+    # Deep comparisons
+
+    is_deeply([1, 2, 3], [1, 2, 3], "Deep comparison");
+
+    #####################
+    # Comparing references
+
+    my $ref = [1];
+    is($ref, $ref, "Check that we have the same ref both times");
+
+    #####################
+    # Things that are gone
+
+    ok(eq_array([1], [1]), "array comparison");
+    ok(eq_hash({a => 1}, {a => 1}), "hash comparison");
+    ok(eq_set([1, 3, 2], [1, 2, 3]), "set comparison");
+
+    note explain([1, 2, 3]);
+
+    {
+        package THING;
+        sub new { bless({}, shift) }
+    }
+
+    my $thing = new_ok('THING');
+
+    #####################
+    # Tools that changed
+
+    isa_ok($thing, 'THING', '$thing');
+
+    can_ok(__PACKAGE__, qw/ok is/);
+
+=head1 BOILERPLATE
+
+BEFORE:
+
+    use strict;
+    use warnings;
+
+    use Test::More tests => 14;
+
+    use_ok 'Scalar::Util';
+    require_ok 'Exporter';
+
+AFTER:
+
+    use Test2::V0;
+    plan(11);
+
+    use Scalar::Util;
+    require Exporter;
+
+=over 4
+
+=item Replace Test::More with Test2::V0
+
+L<Test2::V0> is the recommended bundle. In a full migration you
+will want to replace L<Test::More> with the L<Test2::V0> bundle.
+
+B<Note:> You should always double check the latest L<Test2> to see if there is
+a new recommended bundle. When writing a new test you should always use the
+newest Test::V# module. Higher numbers are newer version.
+
+=item Stop using use_ok()
+
+C<use_ok()> has been removed. a C<use MODULE> statement will throw an exception
+on failure anyway preventing the test from passing.
+
+If you I<REALLY> want/need to assert that the file loaded you can use the L<ok>
+module:
+
+    use ok 'Scalar::Util';
+
+The main difference here is that there is a space instead of an underscore.
+
+=item Stop using require_ok()
+
+C<require_ok> has been removed just like C<use_ok>. There is no L<ok> module
+equivalent here. Just use C<require>.
+
+=item Remove strict/warnings (optional)
+
+The L<Test2::V0> bundle turns strict and warnings on for you.
+
+=item Change where the plan is set
+
+Test2 does not allow you to set the plan at import. In the old code you would
+pass C<< tests => 11 >> as an import argument. In L<Test2> you either need to
+use the C<plan()> function to set the plan, or use C<done_testing()> at the end
+of the test.
+
+If your test already uses C<done_testing()> you can keep that and no plan
+changes are necessary.
+
+B<Note:> We are also changing the plan from 14 to 11, that is because we
+dropped C<use_ok>, C<require_ok>, and we will be dropping one more later on.
+This is why C<done_testing()> is recommended over a set plan.
+
+=back
+
+=head1 SIMPLE ASSERTIONS
+
+The vast majority of assertions will not need any changes:
+
+    #####################
+    # Simple assertions (no changes)
+
+    ok(1, "pass");
+
+    is("apple", "apple", "Simple string compare");
+
+    like("foo bar baz", qr/bar/, "Regex match");
+
+=head1 TODO
+
+    {
+        local $TODO = "These are todo";
+
+        ok(0, "oops");
+    }
+
+The C<$TODO> package variable is gone. You now have a C<todo()> function.
+
+There are 2 ways this can be used:
+
+=over 4
+
+=item todo $reason => sub { ... }
+
+    todo "These are todo" => sub {
+        ok(0, "oops");
+    };
+
+This is the cleanest way to do a todo. This will make all assertions inside the
+codeblock into TODO assertions.
+
+=item { my $TODO = todo $reason; ... }
+
+    {
+        my $TODO = todo "These are todo";
+
+        ok(0, "oops");
+    }
+
+This is a system that emulates the old way. Instead of modifying a global
+C<$TODO> variable you create a todo object with the C<todo()> function and
+assign it to a lexical variable. Once the todo object falls out of scope the
+TODO ends.
+
+=back
+
+=head1 DEEP COMPARISONS
+
+    is_deeply([1, 2, 3], [1, 2, 3], "Deep comparison");
+
+Deep comparisons are easy, simply replace C<is_deeply()> with C<is()>.
+
+    is([1, 2, 3], [1, 2, 3], "Deep comparison");
+
+=head1 COMPARING REFERENCES
+
+    my $ref = [1];
+    is($ref, $ref, "Check that we have the same ref both times");
+
+The C<is()> function provided by L<Test::More> forces both arguments into
+strings, which makes this a comparison of the reference addresses. L<Test2>'s
+C<is()> function is a deep comparison, so this will still pass, but fails to
+actually test what we want (that both references are the same exact ref, not
+just identical structures.)
+
+We now have the C<ref_is()> function that does what we really want, it ensures
+both references are the same reference. This function does the job better than
+the original, which could be thrown off by string overloading.
+
+    my $ref = [1];
+    ref_is($ref, $ref, "Check that we have the same ref both times");
+
+=head1 TOOLS THAT ARE GONE
+
+    ok(eq_array([1], [1]), "array comparison");
+    ok(eq_hash({a => 1}, {a => 1}), "hash comparison");
+    ok(eq_set([1, 3, 2], [1, 2, 3]), "set comparison");
+
+    note explain([1, 2, 3]);
+
+    {
+        package THING;
+        sub new { bless({}, shift) }
+    }
+
+    my $thing = new_ok('THING');
+
+C<eq_array>, C<eq_hash> and C<eq_set> have been considered deprecated for a
+very long time, L<Test2> does not provide them at all. Instead you can just use
+C<is()>:
+
+    is([1], [1], "array comparison");
+    is({a => 1}, {a => 1}, "hash comparison");
+
+C<eq_set> is a tad more complicated, see L<Test2::Tools::Compare> for an
+explanation:
+
+    is([1, 3, 2], bag { item 1; item 2; item 3; end }, "set comparison");
+
+C<explain()> has a rocky history. There have been arguments about how it should
+work. L<Test2> decided to simply not include C<explain()> to avoid the
+arguments. You can instead directly use Data::Dumper:
+
+    use Data::Dumper;
+    note Dumper([1, 2, 3]);
+
+C<new_ok()> is gone. The implementation was complicated, and did not add much
+value:
+
+    {
+        package THING;
+        sub new { bless({}, shift) }
+    }
+
+    my $thing = THING->new;
+    ok($thing, "made a new thing");
+
+The complete section after the conversion is:
+
+    is([1], [1], "array comparison");
+    is({a => 1}, {a => 1}, "hash comparison");
+    is([1, 3, 2], bag { item 1; item 2; item 3; end }, "set comparison");
+
+    use Data::Dumper;
+    note Dumper([1, 2, 3]);
+
+    {
+        package THING;
+        sub new { bless({}, shift) }
+    }
+
+    my $thing = THING->new;
+    ok($thing, "made a new thing");
+
+=head1 TOOLS THAT HAVE CHANGED
+
+    isa_ok($thing, 'THING', '$thing');
+
+    can_ok(__PACKAGE__, qw/ok is/);
+
+In L<Test::More> these functions are very confusing, and most people use them
+wrong!
+
+C<isa_ok()> from L<Test::More> takes a thing, a class/reftype to check, and
+then uses the third argument as an alternative display name for the first
+argument (NOT a test name!).
+
+C<can_ok()> from L<Test::More> is not consistent with C<isa_ok> as all
+arguments after the first are subroutine names.
+
+L<Test2> fixes this by making both functions consistent and obvious:
+
+    isa_ok($thing, ['THING'], 'got a THING');
+
+    can_ok(__PACKAGE__, [qw/ok is/], "have expected subs");
+
+You will note that both functions take a thing, an arrayref as the second
+argument, then a test name as the third argument.
+
+=head1 FINAL VERSION
+
+    #####################
+    # Boilerplate
+
+    use Test2::V0;
+    plan(11);
+
+    use Scalar::Util;
+    require Exporter;
+
+    #####################
+    # Simple assertions (no changes)
+
+    ok(1, "pass");
+
+    is("apple", "apple", "Simple string compare");
+
+    like("foo bar baz", qr/bar/, "Regex match");
+
+    #####################
+    # Todo
+
+    todo "These are todo" => sub {
+        ok(0, "oops");
+    };
+
+    #####################
+    # Deep comparisons
+
+    is([1, 2, 3], [1, 2, 3], "Deep comparison");
+
+    #####################
+    # Comparing references
+
+    my $ref = [1];
+    ref_is($ref, $ref, "Check that we have the same ref both times");
+
+    #####################
+    # Things that are gone
+
+    is([1], [1], "array comparison");
+    is({a => 1}, {a => 1}, "hash comparison");
+
+    is([1, 3, 2], bag { item 1; item 2; item 3; end }, "set comparison");
+
+    use Data::Dumper;
+    note Dumper([1, 2, 3]);
+
+    {
+        package THING;
+        sub new { bless({}, shift) }
+    }
+
+    my $thing = THING->new;
+
+    #####################
+    # Tools that changed
+
+    isa_ok($thing, ['THING'], 'got a THING');
+
+    can_ok(__PACKAGE__, [qw/ok is/], "have expected subs");
+
+=head1 SEE ALSO
+
+L<Test2::Manual> - Primary index of the manual.
+
+=head1 SOURCE
+
+The source code repository for Test2-Manual can be found at
+F<https://github.com/Test-More/Test2-Suite/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2018 Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut
+
+
+

database/perl/vendor/lib/Test2/Manual/Testing/Planning.pm

@@ -0,0 +1,104 @@
+package Test2::Manual::Testing::Planning;
+use strict;
+use warnings;
+
+our $VERSION = '0.000139';
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test2::Manual::Testing::Planning - The many ways to set a plan.
+
+=head1 DESCRIPTION
+
+This tutorial covers the many ways of setting a plan.
+
+=head1 TEST COUNT
+
+The C<plan()> function is provided by L<Test2::Tools::Basic>. This function lets
+you specify an exact number of tests to run. This can be done at the start of
+testing, or at the end. This cannot be done partway through testing.
+
+    use Test2::Tools::Basic;
+    plan(10); # 10 tests expected
+
+    ...
+
+=head1 DONE TESTING
+
+The C<done_testing()> function is provided by L<Test2::Tools::Basic>. This
+function will automatically set the plan to the number of tests that were run.
+This must be used at the very end of testing.
+
+    use Test2::Tools::Basic;
+
+    ...
+
+    done_testing();
+
+=head1 SKIP ALL
+
+The C<skip_all()> function is provided by L<Test2::Tools::Basic>. This function
+will set the plan to C<0>, and exit the test immediately. You may provide a skip
+reason that explains why the test should be skipped.
+
+    use Test2::Tools::Basic;
+    skip_all("This test will not run here") if ...;
+
+    ...
+
+=head1 CUSTOM PLAN EVENT
+
+A plan is simply an L<Test2::Event::Plan> event that gets sent to the current
+hub. You could always write your own tool to set the plan.
+
+    use Test2::API qw/context/;
+
+    sub set_plan {
+        my $count = @_;
+
+        my $ctx = context();
+        $ctx->send_event('Plan', max => $count);
+        $ctx->release;
+
+        return $count;
+    }
+
+=head1 SEE ALSO
+
+L<Test2::Manual> - Primary index of the manual.
+
+=head1 SOURCE
+
+The source code repository for Test2-Manual can be found at
+F<https://github.com/Test-More/Test2-Suite/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2018 Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

database/perl/vendor/lib/Test2/Manual/Testing/Todo.pm

@@ -0,0 +1,112 @@
+package Test2::Manual::Testing::Todo;
+use strict;
+use warnings;
+
+our $VERSION = '0.000139';
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test2::Manual::Testing::Todo - Tutorial for marking tests as TODO.
+
+=head1 DESCRIPTION
+
+This tutorial covers the process of marking tests as TODO. It also describes
+how TODO works under the hood.
+
+=head1 THE TOOL
+
+    use Test2::Tools::Basic qw/todo/;
+
+=head2 TODO BLOCK
+
+This form is low-magic. All tests inside the block are marked as todo, tests
+outside the block are not todo. You do not need to do any variable management.
+The flaw with this form is that it adds a couple levels to the stack, which can
+break some high-magic tests.
+
+Overall this is the preferred form unless you have a special case that requires
+the variable form.
+
+    todo "Reason for the todo" => sub {
+        ok(0, "fail but todo");
+        ...
+    };
+
+=head2 TODO VARIABLE
+
+This form maintains the todo scope for the life of the variable. This is useful
+for tests that are sensitive to scope changes. This closely emulates the
+L<Test::More> style which localized the C<$TODO> package variable. Once the
+variable is destroyed (set it to undef, scope end, etc) the TODO state ends.
+
+    my $todo = todo "Reason for the todo";
+    ok(0, "fail but todo");
+    ...
+    $todo = undef;
+
+=head1 MANUAL TODO EVENTS
+
+    use Test2::API qw/context/;
+
+    sub todo_ok {
+        my ($bool, $name, $todo) = @_;
+
+        my $ctx = context();
+        $ctx->send_event('Ok', pass => $bool, effective_pass => 1, todo => $todo);
+        $ctx->release;
+
+        return $bool;
+    }
+
+The L<Test2::Event::Ok> event has a C<todo> field which should have the todo
+reason. The event also has the C<pass> and C<effective_pass> fields. The
+C<pass> field is the actual pass/fail value. The C<effective_pass> is used to
+determine if the event is an actual failure (should always be set tot true with
+todo).
+
+=head1 HOW THE TODO TOOLS WORK UNDER THE HOOD
+
+The L<Test2::Todo> library gets the current L<Test2::Hub> instance and adds a
+filter. The filter that is added will set the todo and effective pass fields on
+any L<Test2::Event::Ok> events that pass through the hub. The filter also
+converts L<Test2::Event::Diag> events into L<Test2::Event::Note> events.
+
+=head1 SEE ALSO
+
+L<Test2::Manual> - Primary index of the manual.
+
+=head1 SOURCE
+
+The source code repository for Test2-Manual can be found at
+F<https://github.com/Test-More/Test2-Suite/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2018 Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut