Provided by: libtest-trap-perl_0.2.3-1_all bug

NAME

       Test::Trap::Builder - Backend for building test traps

VERSION

       Version 0.2.3

SYNOPSIS

         package My::Test::Trap;

         use Test::Trap::Builder;
         my $B = Test::Trap::Builder->new;

         $B->layer( $layer_name => \&layer_implementation );
         $B->accessor( simple => [ $layer_name ] );

         $B->multi_layer( $multi_name => @names );

         $B->test( $test_name => 'trap, predicate, name', \&test_function );

DESCRIPTION

       Test::Trap neither traps nor tests everything you may want to trap or test.  So,
       Test::Trap::Builder provides methods to write your own trap layers, accessors, and test
       callbacks -- preferably for use with your own modules (trappers).

       Note that layers are methods with mangled names (names are prefixed with "layer:"), and so
       inherited like any other method, while accessors are ordinary methods.  Meanwhile, test
       callbacks are not referenced in the symbol table by themselves, but only in combinations
       with accessors, all methods of the form ACCESSOR_TEST.

EXPORTS

       Trappers should not inherit from Test::Trap::Builder, but may import a few convenience
       methods for use in building the trap.  Do not use them as methods of Test::Trap::Builder
       -- they are intended to be methods of trap objects.  (If you inherit from another trapper,
       you need not, and probably should not, import these yourself -- you should inherit these
       methods like any other.)

       Trappers may import any number of these methods, or all of them by way of the ":methods"
       tag.

       Layers should be implemented as methods, and while they need not call any of these
       convenience methods in turn, that likely makes for more readable code than any
       alternative.  Likewise, test callbacks may use convenience methods for more readable code.

       Of course, certain convenience methods may also be useful in more generic methods messing
       with trap or builder objects.

   Prop [PACKAGE]
       A method returning a reference to a hash, holding the PACKAGE's (by default the caller's)
       tag-on properties for the (current) trap object.  Currently, Test::Trap::Builder defines
       the following properties:

       layers
           While the trap is springing, the queue of layers remaining.  Usually set by the "trap"
           method and consumed by the "Next" method.

       teardown
           While the trap is springing, the queue of teardown actions remaining.  Usually
           accumulated through the "Teardown" method and invoked by the "trap" method.

       code
           The user code trapped.  Usually set by the "trap" method and invoked by the "Run"
           method.

       exception
           An internal exception.  Usually set through the "Exception" method and examined by the
           "trap" method.

       on_test_failure
           A callback invoked by the "TestFailure" method.  Layers in particular may want to set
           this.

       test_accessor
           The name and (optionally) the index of the accessor, the contents of which we're
           currently testing.  Best accessed through the "TestAccessor" method, and usually set
           by the "test" and "accessor" methods, but if you are writing your own tests or
           accessors directly, you just might need to set it.  Perhaps.

       Be nice: Treat another module's tag-on properties as you would treat another module's
       global variables.  Don't use them except as documented.

       Example:

         # in a layer, setting the callback for TestFailure:
         $self->Prop('Test::Trap::Builder')->{on_test_failure} = \&mydiag;

   DESTROY
       This cleans up the tag-on properties when the trap object is destroyed.  Don't try to make
       a trapper that doesn't call this; it will get confused.

       If your trapper needs its own "DESTROY", make sure it calls this one as well:

         sub DESTROY {
           my $self = shift;
           # do your thing
           $self->Test::Trap::Builder::DESTROY;
           # and more things
         }

   Run
       A terminating layer should call this method to run the user code.  Should only be called
       in a dynamic context in which layers are being applied.

   Next
       Every non-terminating layer should call this method (or an equivalent) to progress to the
       next layer.  Should only be called in a dynamic context in which layers are being applied.
       Note that this method need not return, so any tear-down actions should probably be
       registered with the Teardown method (see below).

   Teardown SUBS
       If your layer wants to clean up its setup, it may use this method to register any number
       of tear-down actions, to be performed (in reverse registration order) once the user code
       has been executed.  Should only be called in a dynamic context in which layers are being
       applied.

   TestAccessor
       Returns a string of the form "NAME(INDEX)", where NAME and INDEX are the name of the
       accessor and the index (if any) being tested.  Should only be called in the dynamic
       context of test callbacks.

       This is intended for diagnostics:

         diag( sprintf 'Expected %s in %s; got %s',
               $expected, $self->TestAccessor, dump($got),
             );

   TestFailure
       Runs the "on_test_failure" tag-on property (if any) on the trap object.  If you are
       writing unregistered tests, you might want to include (some variation of) this call:

         $ok or $self->TestFailure;

   Exception STRINGS
       Layer implementations may run into exceptional situations, in which they want the entire
       trap to fail.  Unfortunately, another layer may be trapping ordinary exceptions, so you
       need some kind of magic in order to throw an untrappable exception.  This is one
       convenient way.

       Should only be called in a dynamic context in which layers are being applied.

       Note: The Exception method won't work if called from outside of the regular control flow,
       like inside a DESTROY method or signal handler.  If anything like this happens, CORE::exit
       will be called with an exit code of 8.

METHODS

   new
       Returns a singleton object.  Don't expect this module to work with a different instance
       object of this class.

   trap TRAPPER, GLOBREF, LAYERARRAYREF, CODE
       Implements a trap for the TRAPPER module, applying the layers of LAYERARRAYREF, trapping
       various outcomes of the user CODE, and storing the trap object into the scalar slot of
       GLOBREF.

       In most cases, the trapper should conveniently export a function calling this method.

   layer NAME, CODE
       Registers a layer by NAME to the calling trapper.  When the layer is applied, the CODE
       will be invoked on the trap object being built, with no arguments, and should call either
       the Next() or Run() method or equivalent.

   output_layer NAME, GLOBREF
       Registers (by NAME and to the calling trapper) a layer for trapping output on the file
       handle of the GLOBREF, using NAME also as the attribute name.

   output_layer_backend NAME, [CODE]
       When called with two arguments, registers (by NAME and globally) a backend for output trap
       layers.  When called with a single argument, looks up and returns the backend registered
       by NAME (or undef).

       When a layer using this backend is applied, the CODE will be called on the trap object,
       with the layer name and the output handle's fileno and globref as arguments.

   first_output_layer_backend SPEC
       Where SPEC is empty, just returns.

       Where SPEC is a string of comma-or-semicolon separated backend names, runs through the
       names, returning the first implementation it finds.  Dies if no implementation is found by
       any of these names.

   multi_layer NAME, LAYERS
       Registers (by NAME) a layer that just pushes a number of other LAYERS on the stack of
       layers.  If any of the LAYERS is neither an anonymous method nor the name of a layer
       registered to the caller or a trapper it inherits from, an exception is raised.

   layer_implementation TRAPPER, LAYERS
       Returns the subroutines that implement the requested LAYERS.  If any of the LAYERS is
       neither an anonymous method nor the name of a layer registered to or inherited by the
       TRAPPER, an exception is raised.

   accessor NAMED_ARGS
       Generates and registers any number of accessors according to the NAMED_ARGS, and also
       generates the proper test methods for these accessors (see below).

       The following named arguments are recognized:

       is_leaveby
           If true, the tests methods will generate better diagnostics if the trap was not left
           as specified.  Also, a special did_ACCESSOR test method will be generated (unless
           already present), simply passing as long as the trap was left as specified.

       is_array
           If true, the simple accessor(s) will be smart about context and arguments, returning
           an arrayref on no argument (in any context), an array slice in list context (on any
           number of arguments), and the element indexed by the first argument otherwise.

       simple
           Should be a reference to an array of accessor names.  For each name, an accessor
           (assuming hash based trap object with accessor names as keys), will be generated and
           registered.

       flexible
           Should be a reference to a hash.  For each pair, a name and an implementation, an
           accessor is generated and registered.

   test NAME, ARGSPEC, CODE
       Registers a test callback by NAME and to the calling trapper.

       Trappers inherit test callbacks like methods (though they are not implemented as such;
       don't expect to find them in the symbol table).

       Test methods of the form ACCESSOR_TEST will be made available (directly or by inheritance)
       to every trapper that registers or inherits both the accessor named ACCESSOR and the test
       named TEST.

       (In more detail, the method will be generated in every trapper that either (1) registers
       both the test and the accessor, or (2) registers either and inherits the other.)

       When the test method is called, any implicit leaveby condition will be tested first, and
       if it passes (or there were none), the CODE is called with arguments according to the
       words found in the ARGSPEC string:

       trap
           The trap object.

       entirety
           The ACCESSOR's return value when called without arguments.

       element
           The ACCESSOR's return value when called with index, if applicable (i.e. for array
           accessors).  Index is not applicable to scalar accessors, so such are still called
           without index.

           The index, when applicable, will be taken from the test method's arguments.

       predicate
           What the ACCESSOR's return value should be tested against (taken from the test
           method's arguments).  (There may be any fixed number of predicates.)

       name
           The test name (taken from the test method's arguments).

EXAMPLE

       A complete example, implementing a timeout layer (depending on Time::HiRes::ualarm being
       present), a simpletee layer (printing the trapped stdout/stderr to the original file
       handles after the trap has sprung), and a cmp_ok test method template:

         package My::Test::Trap;
         use base 'Test::Trap'; # for example
         use Test::Trap::Builder;

         my $B = Test::Trap::Builder->new;

         # example (layer:timeout):
         use Time::HiRes qw/ualarm/;
         $B->layer( timeout => $_ ) for sub {
           my $self = shift;
           eval {
             local $SIG{ALRM} = sub {
               $self->{timeout} = 1; # simple truth
               $SIG{ALRM} = sub {die};
               die;
             };
             ualarm 1000, 1; # one second max, then die repeatedly!
             $self->Next;
           };
           alarm 0;
           if ($self->{timeout}) {
             $self->{leaveby} = 'timeout';
             delete $self->{$_} for qw/ die exit return /;
           }
         };
         $B->accessor( is_leaveby => 1,
                       simple => ['timeout'],
                     );

         # example (layer:simpletee):
         $B->layer( simpletee => $_ ) for sub {
           my $self = shift;
           for (qw/ stdout stderr /) {
             exists $self->{$_} or $self->Exception("Too late to tee $_");
           }
           $self->Teardown($_) for sub {
             print STDOUT $self->{stdout} if exists $self->{stdout};
             print STDERR $self->{stderr} if exists $self->{stderr};
           };
           $self->Next;
         };
         # no accessor for this layer

         $B->multi_layer( flow => qw/ raw die exit timeout / );
         $B->multi_layer( default => qw/ flow stdout stderr warn simpletee / );

         $B->test_method( cmp_ok => 1, 2, \&Test::More::cmp_ok );

CAVEATS

       The interface of this module is likely to remain somewhat in flux for a while yet.

       The different implementations of output trap layers have their own caveats; see
       Test::Trap::Builder::Tempfile, Test::Trap::Builder::PerlIO,
       Test::Trap::Builder::SystemSafe.

       Multiple inheritance is not (yet?) fully supported.  If one parent has registered a test
       callback "X" and another has registered an accessor "Y", the test method "Y_X" will not be
       generated.

       Threads?  No idea.  It might even work correctly.

BUGS

       Please report any bugs or feature requests directly to the author.

AUTHOR

       Eirik Berg Hanssen, "<ebhanssen@allverden.no>"

COPYRIGHT & LICENSE

       Copyright 2006-2012 Eirik Berg Hanssen, All Rights Reserved.

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