1Test2::API(3)         User Contributed Perl Documentation        Test2::API(3)
2
3
4

NAME

6       Test2::API - Primary interface for writing Test2 based testing tools.
7

***INTERNALS NOTE***

9       The internals of this package are subject to change at any time! The
10       public methods provided will not change in backwards-incompatible ways
11       (once there is a stable release), but the underlying implementation
12       details might.  Do not break encapsulation here!
13
14       Currently the implementation is to create a single instance of the
15       Test2::API::Instance Object. All class methods defer to the single
16       instance. There is no public access to the singleton, and that is
17       intentional.  The class methods provided by this package provide the
18       only functionality publicly exposed.
19
20       This is done primarily to avoid the problems Test::Builder had by
21       exposing its singleton. We do not want anyone to replace this
22       singleton, rebless it, or directly muck with its internals. If you need
23       to do something and cannot because of the restrictions placed here,
24       then please report it as an issue. If possible, we will create a way
25       for you to implement your functionality without exposing things that
26       should not be exposed.
27

DESCRIPTION

29       This package exports all the functions necessary to write and/or verify
30       testing tools. Using these building blocks you can begin writing test
31       tools very quickly. You are also provided with tools that help you to
32       test the tools you write.
33

SYNOPSIS

35   WRITING A TOOL
36       The "context()" method is your primary interface into the Test2
37       framework.
38
39           package My::Ok;
40           use Test2::API qw/context/;
41
42           our @EXPORT = qw/my_ok/;
43           use base 'Exporter';
44
45           # Just like ok() from Test::More
46           sub my_ok($;$) {
47               my ($bool, $name) = @_;
48               my $ctx = context(); # Get a context
49               $ctx->ok($bool, $name);
50               $ctx->release; # Release the context
51               return $bool;
52           }
53
54       See Test2::API::Context for a list of methods available on the context
55       object.
56
57   TESTING YOUR TOOLS
58       The "intercept { ... }" tool lets you temporarily intercept all events
59       generated by the test system:
60
61           use Test2::API qw/intercept/;
62
63           use My::Ok qw/my_ok/;
64
65           my $events = intercept {
66               # These events are not displayed
67               my_ok(1, "pass");
68               my_ok(0, "fail");
69           };
70
71           my_ok(@$events == 2, "got 2 events, the pass and the fail");
72           my_ok($events->[0]->pass, "first event passed");
73           my_ok(!$events->[1]->pass, "second event failed");
74
75       DEEP EVENT INTERCEPTION
76
77       Normally "intercept { ... }" only intercepts events sent to the main
78       hub (as added by intercept itself). Nested hubs, such as those created
79       by subtests, will not be intercepted. This is normally what you will
80       still see the nested events by inspecting the subtest event. However
81       there are times where you want to verify each event as it is sent, in
82       that case use "intercept_deep { ... }".
83
84           my $events = intercept_Deep {
85               buffered_subtest foo => sub {
86                   ok(1, "pass");
87               };
88           };
89
90       $events in this case will contain 3 items:
91
92       The event from "ok(1, "pass")"
93       The plan event for the subtest
94       The subtest event itself, with the first 2 events nested inside it as
95       children.
96
97       This lets you see the order in which the events were sent, unlike
98       "intercept { ... }" which only lets you see events as the main hub sees
99       them.
100
101   OTHER API FUNCTIONS
102           use Test2::API qw{
103               test2_init_done
104               test2_stack
105               test2_set_is_end
106               test2_get_is_end
107               test2_ipc
108               test2_formatter_set
109               test2_formatter
110               test2_is_testing_done
111           };
112
113           my $init  = test2_init_done();
114           my $stack = test2_stack();
115           my $ipc   = test2_ipc();
116
117           test2_formatter_set($FORMATTER)
118           my $formatter = test2_formatter();
119
120           ... And others ...
121

MAIN API EXPORTS

123       All exports are optional. You must specify subs to import.
124
125           use Test2::API qw/context intercept run_subtest/;
126
127       This is the list of exports that are most commonly needed. If you are
128       simply writing a tool, then this is probably all you need. If you need
129       something and you cannot find it here, then you can also look at "OTHER
130       API EXPORTS".
131
132       These exports lack the 'test2_' prefix because of how important/common
133       they are. Exports in the "OTHER API EXPORTS" section have the 'test2_'
134       prefix to ensure they stand out.
135
136   context(...)
137       Usage:
138
139       $ctx = context()
140       $ctx = context(%params)
141
142       The "context()" function will always return the current context. If
143       there is already a context active, it will be returned. If there is not
144       an active context, one will be generated. When a context is generated
145       it will default to using the file and line number where the currently
146       running sub was called from.
147
148       Please see "CRITICAL DETAILS" in Test2::API::Context for important
149       rules about what you can and cannot do with a context once it is
150       obtained.
151
152       Note This function will throw an exception if you ignore the context
153       object it returns.
154
155       Note On perls 5.14+ a depth check is used to insure there are no
156       context leaks. This cannot be safely done on older perls due to
157       <https://rt.perl.org/Public/Bug/Display.html?id=127774> You can
158       forcefully enable it either by setting "$ENV{T2_CHECK_DEPTH} = 1" or
159       "$Test2::API::DO_DEPTH_CHECK = 1" BEFORE loading Test2::API.
160
161       OPTIONAL PARAMETERS
162
163       All parameters to "context" are optional.
164
165       level => $int
166           If you must obtain a context in a sub deeper than your entry point
167           you can use this to tell it how many EXTRA stack frames to look
168           back. If this option is not provided the default of 0 is used.
169
170               sub third_party_tool {
171                   my $sub = shift;
172                   ... # Does not obtain a context
173                   $sub->();
174                   ...
175               }
176
177               third_party_tool(sub {
178                   my $ctx = context(level => 1);
179                   ...
180                   $ctx->release;
181               });
182
183       wrapped => $int
184           Use this if you need to write your own tool that wraps a call to
185           "context()" with the intent that it should return a context object.
186
187               sub my_context {
188                   my %params = ( wrapped => 0, @_ );
189                   $params{wrapped}++;
190                   my $ctx = context(%params);
191                   ...
192                   return $ctx;
193               }
194
195               sub my_tool {
196                   my $ctx = my_context();
197                   ...
198                   $ctx->release;
199               }
200
201           If you do not do this, then tools you call that also check for a
202           context will notice that the context they grabbed was created at
203           the same stack depth, which will trigger protective measures that
204           warn you and destroy the existing context.
205
206       stack => $stack
207           Normally "context()" looks at the global hub stack. If you are
208           maintaining your own Test2::API::Stack instance you may pass it in
209           to be used instead of the global one.
210
211       hub => $hub
212           Use this parameter if you want to obtain the context for a specific
213           hub instead of whatever one happens to be at the top of the stack.
214
215       on_init => sub { ... }
216           This lets you provide a callback sub that will be called ONLY if
217           your call to "context()" generated a new context. The callback WILL
218           NOT be called if "context()" is returning an existing context. The
219           only argument passed into the callback will be the context object
220           itself.
221
222               sub foo {
223                   my $ctx = context(on_init => sub { 'will run' });
224
225                   my $inner = sub {
226                       # This callback is not run since we are getting the existing
227                       # context from our parent sub.
228                       my $ctx = context(on_init => sub { 'will NOT run' });
229                       $ctx->release;
230                   }
231                   $inner->();
232
233                   $ctx->release;
234               }
235
236       on_release => sub { ... }
237           This lets you provide a callback sub that will be called when the
238           context instance is released. This callback will be added to the
239           returned context even if an existing context is returned. If
240           multiple calls to context add callbacks, then all will be called in
241           reverse order when the context is finally released.
242
243               sub foo {
244                   my $ctx = context(on_release => sub { 'will run second' });
245
246                   my $inner = sub {
247                       my $ctx = context(on_release => sub { 'will run first' });
248
249                       # Neither callback runs on this release
250                       $ctx->release;
251                   }
252                   $inner->();
253
254                   # Both callbacks run here.
255                   $ctx->release;
256               }
257
258   release($;$)
259       Usage:
260
261       release $ctx;
262       release $ctx, ...;
263
264       This is intended as a shortcut that lets you release your context and
265       return a value in one statement. This function will get your context,
266       and an optional return value. It will release your context, then return
267       your value. Scalar context is always assumed.
268
269           sub tool {
270               my $ctx = context();
271               ...
272
273               return release $ctx, 1;
274           }
275
276       This tool is most useful when you want to return the value you get from
277       calling a function that needs to see the current context:
278
279           my $ctx = context();
280           my $out = some_tool(...);
281           $ctx->release;
282           return $out;
283
284       We can combine the last 3 lines of the above like so:
285
286           my $ctx = context();
287           release $ctx, some_tool(...);
288
289   context_do(&;@)
290       Usage:
291
292           sub my_tool {
293               context_do {
294                   my $ctx = shift;
295
296                   my (@args) = @_;
297
298                   $ctx->ok(1, "pass");
299
300                   ...
301
302                   # No need to call $ctx->release, done for you on scope exit.
303               } @_;
304           }
305
306       Using this inside your test tool takes care of a lot of boilerplate for
307       you. It will ensure a context is acquired. It will capture and rethrow
308       any exception. It will insure the context is released when you are
309       done. It preserves the subroutine call context (array, scalar, void).
310
311       This is the safest way to write a test tool. The only two downsides to
312       this are a slight performance decrease, and some extra indentation in
313       your source. If the indentation is a problem for you then you can take
314       a peek at the next section.
315
316   no_context(&;$)
317       Usage:
318
319       no_context { ... };
320       no_context { ... } $hid;
321               sub my_tool(&) {
322                   my $code = shift;
323                   my $ctx = context();
324                   ...
325
326                   no_context {
327                       # Things in here will not see our current context, they get a new
328                       # one.
329
330                       $code->();
331                   };
332
333                   ...
334                   $ctx->release;
335               };
336
337       This tool will hide a context for the provided block of code. This
338       means any tools run inside the block will get a completely new context
339       if they acquire one. The new context will be inherited by tools nested
340       below the one that acquired it.
341
342       This will normally hide the current context for the top hub. If you
343       need to hide the context for a different hub you can pass in the
344       optional $hid parameter.
345
346   intercept(&)
347       Usage:
348
349           my $events = intercept {
350               ok(1, "pass");
351               ok(0, "fail");
352               ...
353           };
354
355       This function takes a codeblock as its only argument, and it has a
356       prototype.  It will execute the codeblock, intercepting any generated
357       events in the process. It will return an array reference with all the
358       generated event objects. All events should be subclasses of
359       Test2::Event.
360
361       This is a very low-level subtest tool. This is useful for writing tools
362       which produce subtests. This is not intended for people simply writing
363       tests.
364
365   run_subtest(...)
366       Usage:
367
368           run_subtest($NAME, \&CODE, $BUFFERED, @ARGS)
369
370           # or
371
372           run_subtest($NAME, \&CODE, \%PARAMS, @ARGS)
373
374       This will run the provided codeblock with the args in @args. This
375       codeblock will be run as a subtest. A subtest is an isolated test state
376       that is condensed into a single Test2::Event::Subtest event, which
377       contains all events generated inside the subtest.
378
379       ARGUMENTS:
380
381       $NAME
382           The name of the subtest.
383
384       \&CODE
385           The code to run inside the subtest.
386
387       $BUFFERED or \%PARAMS
388           If this is a simple scalar then it will be treated as a boolean for
389           the 'buffered' setting. If this is a hash reference then it will be
390           used as a parameters hash. The param hash will be used for hub
391           construction (with the specified keys removed).
392
393           Keys that are removed and used by run_subtest:
394
395           'buffered' => $bool
396               Toggle buffered status.
397
398           'inherit_trace' => $bool
399               Normally the subtest hub is pushed and the sub is allowed to
400               generate its own root context for the hub. When this setting is
401               turned on a root context will be created for the hub that
402               shares the same trace as the current context.
403
404               Set this to true if your tool is producing subtests without
405               user-specified subs.
406
407           'no_fork' => $bool
408               Defaults to off. Normally forking inside a subtest will
409               actually fork the subtest, resulting in 2 final subtest events.
410               This parameter will turn off that behavior, only the original
411               process/thread will return a final subtest event.
412
413       @ARGS
414           Any extra arguments you want passed into the subtest code.
415
416       BUFFERED VS UNBUFFERED (OR STREAMED)
417
418       Normally all events inside and outside a subtest are sent to the
419       formatter immediately by the hub. Sometimes it is desirable to hold off
420       sending events within a subtest until the subtest is complete. This
421       usually depends on the formatter being used.
422
423       Things not effected by this flag
424           In both cases events are generated and stored in an array. This
425           array is eventually used to populate the "subevents" attribute on
426           the Test2::Event::Subtest event that is generated at the end of the
427           subtest.  This flag has no effect on this part, it always happens.
428
429           At the end of the subtest, the final Test2::Event::Subtest event is
430           sent to the formatter.
431
432       Things that are effected by this flag
433           The "buffered" attribute of the Test2::Event::Subtest event will be
434           set to the value of this flag. This means any formatter, listener,
435           etc which looks at the event will know if it was buffered.
436
437       Things that are formatter dependant
438           Events within a buffered subtest may or may not be sent to the
439           formatter as they happen. If a formatter fails to specify then the
440           default is to NOT SEND the events as they are generated, instead
441           the formatter can pull them from the "subevents" attribute.
442
443           A formatter can specify by implementing the "hide_buffered()"
444           method. If this method returns true then events generated inside a
445           buffered subtest will not be sent independently of the final
446           subtest event.
447
448       An example of how this is used is the Test2::Formatter::TAP formatter.
449       For unbuffered subtests the events are rendered as they are generated.
450       At the end of the subtest, the final subtest event is rendered, but the
451       "subevents" attribute is ignored. For buffered subtests the opposite
452       occurs, the events are NOT rendered as they are generated, instead the
453       "subevents" attribute is used to render them all at once. This is
454       useful when running subtests tests in parallel, since without it the
455       output from subtests would be interleaved together.
456

OTHER API EXPORTS

458       Exports in this section are not commonly needed. These all have the
459       'test2_' prefix to help ensure they stand out. You should look at the
460       "MAIN API EXPORTS" section before looking here. This section is one
461       where "Great power comes with great responsibility". It is possible to
462       break things badly if you are not careful with these.
463
464       All exports are optional. You need to list which ones you want at
465       import time:
466
467           use Test2::API qw/test2_init_done .../;
468
469   STATUS AND INITIALIZATION STATE
470       These provide access to internal state and object instances.
471
472       $bool = test2_init_done()
473           This will return true if the stack and IPC instances have already
474           been initialized. It will return false if they have not. Init
475           happens as late as possible. It happens as soon as a tool requests
476           the IPC instance, the formatter, or the stack.
477
478       $bool = test2_load_done()
479           This will simply return the boolean value of the loaded flag. If
480           Test2 has finished loading this will be true, otherwise false.
481           Loading is considered complete the first time a tool requests a
482           context.
483
484       test2_set_is_end()
485       test2_set_is_end($bool)
486           This is used to toggle Test2's belief that the END phase has
487           already started.  With no arguments this will set it to true. With
488           arguments it will set it to the first argument's value.
489
490           This is used to prevent the use of "caller()" in END blocks which
491           can cause segfaults. This is only necessary in some persistent
492           environments that may have multiple END phases.
493
494       $bool = test2_get_is_end()
495           Check if Test2 believes it is the END phase.
496
497       $stack = test2_stack()
498           This will return the global Test2::API::Stack instance. If this has
499           not yet been initialized it will be initialized now.
500
501       $bool = test2_is_testing_done()
502           This will return true if testing is complete and no other events
503           should be sent. This is useful in things like warning handlers
504           where you might want to turn warnings into events, but need them to
505           start acting like normal warnings when testing is done.
506
507               $SIG{__WARN__} = sub {
508                   my ($warning) = @_;
509
510                   if (test2_is_testing_done()) {
511                       warn @_;
512                   }
513                   else {
514                       my $ctx = context();
515                       ...
516                       $ctx->release
517                   }
518               }
519
520       test2_ipc_disable
521           Disable IPC.
522
523       $bool = test2_ipc_diabled
524           Check if IPC is disabled.
525
526       test2_ipc_wait_enable()
527       test2_ipc_wait_disable()
528       $bool = test2_ipc_wait_enabled()
529           These can be used to turn IPC waiting on and off, or check the
530           current value of the flag.
531
532           Waiting is turned on by default. Waiting will cause the parent
533           process/thread to wait until all child processes and threads are
534           finished before exiting. You will almost never want to turn this
535           off.
536
537       $bool = test2_no_wait()
538       test2_no_wait($bool)
539           DISCOURAGED: This is a confusing interface, it is better to use
540           "test2_ipc_wait_enable()", "test2_ipc_wait_disable()" and
541           "test2_ipc_wait_enabled()".
542
543           This can be used to get/set the no_wait status. Waiting is turned
544           on by default. Waiting will cause the parent process/thread to wait
545           until all child processes and threads are finished before exiting.
546           You will almost never want to turn this off.
547
548       $fh = test2_stdout()
549       $fh = test2_stderr()
550           These functions return the filehandles that test output should be
551           written to.  They are primarily useful when writing a custom
552           formatter and code that turns events into actual output (TAP,
553           etc.).  They will return a dupe of the original filehandles that
554           formatted output can be sent to regardless of whatever state the
555           currently running test may have left STDOUT and STDERR in.
556
557       test2_reset_io()
558           Re-dupe the internal filehandles returned by "test2_stdout()" and
559           "test2_stderr()" from the current STDOUT and STDERR.  You shouldn't
560           need to do this except in very peculiar situations (for example,
561           you're testing a new formatter and you need control over where the
562           formatter is sending its output.)
563
564   BEHAVIOR HOOKS
565       These are hooks that allow you to add custom behavior to actions taken
566       by Test2 and tools built on top of it.
567
568       test2_add_callback_exit(sub { ... })
569           This can be used to add a callback that is called after all testing
570           is done. This is too late to add additional results, the main use
571           of this callback is to set the exit code.
572
573               test2_add_callback_exit(
574                   sub {
575                       my ($context, $exit, \$new_exit) = @_;
576                       ...
577                   }
578               );
579
580           The $context passed in will be an instance of Test2::API::Context.
581           The $exit argument will be the original exit code before anything
582           modified it.  $$new_exit is a reference to the new exit code. You
583           may modify this to change the exit code. Please note that
584           $$new_exit may already be different from $exit
585
586       test2_add_callback_post_load(sub { ... })
587           Add a callback that will be called when Test2 is finished loading.
588           This means the callback will be run once, the first time a context
589           is obtained.  If Test2 has already finished loading then the
590           callback will be run immediately.
591
592       test2_add_callback_testing_done(sub { ... })
593           This adds your coderef as a follow-up to the root hub after Test2
594           is finished loading.
595
596           This is essentially a helper to do the following:
597
598               test2_add_callback_post_load(sub {
599                   my $stack = test2_stack();
600                   $stack->top; # Insure we have a hub
601                   my ($hub) = Test2::API::test2_stack->all;
602
603                   $hub->set_active(1);
604
605                   $hub->follow_up(sub { ... }); # <-- Your coderef here
606               });
607
608       test2_add_callback_context_acquire(sub { ... })
609           Add a callback that will be called every time someone tries to
610           acquire a context. This will be called on EVERY call to
611           "context()". It gets a single argument, a reference to the hash of
612           parameters being used the construct the context. This is your
613           chance to change the parameters by directly altering the hash.
614
615               test2_add_callback_context_acquire(sub {
616                   my $params = shift;
617                   $params->{level}++;
618               });
619
620           This is a very scary API function. Please do not use this unless
621           you need to.  This is here for Test::Builder and backwards
622           compatibility. This has you directly manipulate the hash instead of
623           returning a new one for performance reasons.
624
625       test2_add_callback_context_init(sub { ... })
626           Add a callback that will be called every time a new context is
627           created. The callback will receive the newly created context as its
628           only argument.
629
630       test2_add_callback_context_release(sub { ... })
631           Add a callback that will be called every time a context is
632           released. The callback will receive the released context as its
633           only argument.
634
635       test2_add_callback_pre_subtest(sub { ... })
636           Add a callback that will be called every time a subtest is going to
637           be run. The callback will receive the subtest name, coderef, and
638           any arguments.
639
640       @list = test2_list_context_acquire_callbacks()
641           Return all the context acquire callback references.
642
643       @list = test2_list_context_init_callbacks()
644           Returns all the context init callback references.
645
646       @list = test2_list_context_release_callbacks()
647           Returns all the context release callback references.
648
649       @list = test2_list_exit_callbacks()
650           Returns all the exit callback references.
651
652       @list = test2_list_post_load_callbacks()
653           Returns all the post load callback references.
654
655       @list = test2_list_pre_subtest_callbacks()
656           Returns all the pre-subtest callback references.
657
658       test2_add_uuid_via(sub { ... })
659       $sub = test2_add_uuid_via()
660           This allows you to provide a UUID generator. If provided UUIDs will
661           be attached to all events, hubs, and contexts. This is useful for
662           storing, tracking, and linking these objects.
663
664           The sub you provide should always return a unique identifier. Most
665           things will expect a proper UUID string, however nothing in
666           Test2::API enforces this.
667
668           The sub will receive exactly 1 argument, the type of thing being
669           tagged 'context', 'hub', or 'event'. In the future additional
670           things may be tagged, in which case new strings will be passed in.
671           These are purely informative, you can (and usually should) ignore
672           them.
673
674   IPC AND CONCURRENCY
675       These let you access, or specify, the IPC system internals.
676
677       $bool = test2_has_ipc()
678           Check if IPC is enabled.
679
680       $ipc = test2_ipc()
681           This will return the global Test2::IPC::Driver instance. If this
682           has not yet been initialized it will be initialized now.
683
684       test2_ipc_add_driver($DRIVER)
685           Add an IPC driver to the list. This will add the driver to the
686           start of the list.
687
688       @drivers = test2_ipc_drivers()
689           Get the list of IPC drivers.
690
691       $bool = test2_ipc_polling()
692           Check if polling is enabled.
693
694       test2_ipc_enable_polling()
695           Turn on polling. This will cull events from other processes and
696           threads every time a context is created.
697
698       test2_ipc_disable_polling()
699           Turn off IPC polling.
700
701       test2_ipc_enable_shm()
702           Legacy, this is currently a no-op that returns 0;
703
704       test2_ipc_set_pending($uniq_val)
705           Tell other processes and events that an event is pending. $uniq_val
706           should be a unique value no other thread/process will generate.
707
708           Note: After calling this "test2_ipc_get_pending()" will return 1.
709           This is intentional, and not avoidable.
710
711       $pending = test2_ipc_get_pending()
712           This returns -1 if there is no way to check (assume yes)
713
714           This returns 0 if there are (most likely) no pending events.
715
716           This returns 1 if there are (likely) pending events. Upon return it
717           will reset, nothing else will be able to see that there were
718           pending events.
719
720       $timeout = test2_ipc_get_timeout()
721       test2_ipc_set_timeout($timeout)
722           Get/Set the timeout value for the IPC system. This timeout is how
723           long the IPC system will wait for child processes and threads to
724           finish before aborting.
725
726           The default value is 30 seconds.
727
728   MANAGING FORMATTERS
729       These let you access, or specify, the formatters that can/should be
730       used.
731
732       $formatter = test2_formatter
733           This will return the global formatter class. This is not an
734           instance. By default the formatter is set to Test2::Formatter::TAP.
735
736           You can override this default using the "T2_FORMATTER" environment
737           variable.
738
739           Normally 'Test2::Formatter::' is prefixed to the value in the
740           environment variable:
741
742               $ T2_FORMATTER='TAP' perl test.t     # Use the Test2::Formatter::TAP formatter
743               $ T2_FORMATTER='Foo' perl test.t     # Use the Test2::Formatter::Foo formatter
744
745           If you want to specify a full module name you use the '+' prefix:
746
747               $ T2_FORMATTER='+Foo::Bar' perl test.t     # Use the Foo::Bar formatter
748
749       test2_formatter_set($class_or_instance)
750           Set the global formatter class. This can only be set once. Note:
751           This will override anything specified in the 'T2_FORMATTER'
752           environment variable.
753
754       @formatters = test2_formatters()
755           Get a list of all loaded formatters.
756
757       test2_formatter_add($class_or_instance)
758           Add a formatter to the list. Last formatter added is used at
759           initialization. If this is called after initialization a warning
760           will be issued.
761

OTHER EXAMPLES

763       See the "/Examples/" directory included in this distribution.
764

SEE ALSO

766       Test2::API::Context - Detailed documentation of the context object.
767
768       Test2::IPC - The IPC system used for threading/fork support.
769
770       Test2::Formatter - Formatters such as TAP live here.
771
772       Test2::Event - Events live in this namespace.
773
774       Test2::Hub - All events eventually funnel through a hub. Custom hubs
775       are how "intercept()" and "run_subtest()" are implemented.
776

MAGIC

778       This package has an END block. This END block is responsible for
779       setting the exit code based on the test results. This end block also
780       calls the callbacks that can be added to this package.
781

SOURCE

783       The source code repository for Test2 can be found at
784       http://github.com/Test-More/test-more/.
785

MAINTAINERS

787       Chad Granum <exodist@cpan.org>
788

AUTHORS

790       Chad Granum <exodist@cpan.org>
791
793       Copyright 2019 Chad Granum <exodist@cpan.org>.
794
795       This program is free software; you can redistribute it and/or modify it
796       under the same terms as Perl itself.
797
798       See http://dev.perl.org/licenses/
799
800
801
802perl v5.30.2                      2020-03-31                     Test2::API(3)
Impressum