Add files using upload-large-folder tool

my_container_sandbox/usr/share/perl/5.30.0/Archive/Tar/File.pm

@@ -0,0 +1,716 @@
+package Archive::Tar::File;
+use strict;
+
+use Carp                ();
+use IO::File;
+use File::Spec::Unix    ();
+use File::Spec          ();
+use File::Basename      ();
+
+### avoid circular use, so only require;
+require Archive::Tar;
+use Archive::Tar::Constant;
+
+use vars qw[@ISA $VERSION];
+#@ISA        = qw[Archive::Tar];
+$VERSION    = '2.32';
+
+### set value to 1 to oct() it during the unpack ###
+
+my $tmpl = [
+        name        => 0,   # string					A100
+        mode        => 1,   # octal					A8
+        uid         => 1,   # octal					A8
+        gid         => 1,   # octal					A8
+        size        => 0,   # octal	# cdrake - not *always* octal..	A12
+        mtime       => 1,   # octal					A12
+        chksum      => 1,   # octal					A8
+        type        => 0,   # character					A1
+        linkname    => 0,   # string					A100
+        magic       => 0,   # string					A6
+        version     => 0,   # 2 bytes					A2
+        uname       => 0,   # string					A32
+        gname       => 0,   # string					A32
+        devmajor    => 1,   # octal					A8
+        devminor    => 1,   # octal					A8
+        prefix      => 0,	#					A155 x 12
+
+### end UNPACK items ###
+        raw         => 0,   # the raw data chunk
+        data        => 0,   # the data associated with the file --
+                            # This  might be very memory intensive
+];
+
+### install get/set accessors for this object.
+for ( my $i=0; $i<scalar @$tmpl ; $i+=2 ) {
+    my $key = $tmpl->[$i];
+    no strict 'refs';
+    *{__PACKAGE__."::$key"} = sub {
+        my $self = shift;
+        $self->{$key} = $_[0] if @_;
+
+        ### just in case the key is not there or undef or something ###
+        {   local $^W = 0;
+            return $self->{$key};
+        }
+    }
+}
+
+=head1 NAME
+
+Archive::Tar::File - a subclass for in-memory extracted file from Archive::Tar
+
+=head1 SYNOPSIS
+
+    my @items = $tar->get_files;
+
+    print $_->name, ' ', $_->size, "\n" for @items;
+
+    print $object->get_content;
+    $object->replace_content('new content');
+
+    $object->rename( 'new/full/path/to/file.c' );
+
+=head1 DESCRIPTION
+
+Archive::Tar::Files provides a neat little object layer for in-memory
+extracted files. It's mostly used internally in Archive::Tar to tidy
+up the code, but there's no reason users shouldn't use this API as
+well.
+
+=head2 Accessors
+
+A lot of the methods in this package are accessors to the various
+fields in the tar header:
+
+=over 4
+
+=item name
+
+The file's name
+
+=item mode
+
+The file's mode
+
+=item uid
+
+The user id owning the file
+
+=item gid
+
+The group id owning the file
+
+=item size
+
+File size in bytes
+
+=item mtime
+
+Modification time. Adjusted to mac-time on MacOS if required
+
+=item chksum
+
+Checksum field for the tar header
+
+=item type
+
+File type -- numeric, but comparable to exported constants -- see
+Archive::Tar's documentation
+
+=item linkname
+
+If the file is a symlink, the file it's pointing to
+
+=item magic
+
+Tar magic string -- not useful for most users
+
+=item version
+
+Tar version string -- not useful for most users
+
+=item uname
+
+The user name that owns the file
+
+=item gname
+
+The group name that owns the file
+
+=item devmajor
+
+Device major number in case of a special file
+
+=item devminor
+
+Device minor number in case of a special file
+
+=item prefix
+
+Any directory to prefix to the extraction path, if any
+
+=item raw
+
+Raw tar header -- not useful for most users
+
+=back
+
+=head1 Methods
+
+=head2 Archive::Tar::File->new( file => $path )
+
+Returns a new Archive::Tar::File object from an existing file.
+
+Returns undef on failure.
+
+=head2 Archive::Tar::File->new( data => $path, $data, $opt )
+
+Returns a new Archive::Tar::File object from data.
+
+C<$path> defines the file name (which need not exist), C<$data> the
+file contents, and C<$opt> is a reference to a hash of attributes
+which may be used to override the default attributes (fields in the
+tar header), which are described above in the Accessors section.
+
+Returns undef on failure.
+
+=head2 Archive::Tar::File->new( chunk => $chunk )
+
+Returns a new Archive::Tar::File object from a raw 512-byte tar
+archive chunk.
+
+Returns undef on failure.
+
+=cut
+
+sub new {
+    my $class   = shift;
+    my $what    = shift;
+
+    my $obj =   ($what eq 'chunk') ? __PACKAGE__->_new_from_chunk( @_ ) :
+                ($what eq 'file' ) ? __PACKAGE__->_new_from_file( @_ ) :
+                ($what eq 'data' ) ? __PACKAGE__->_new_from_data( @_ ) :
+                undef;
+
+    return $obj;
+}
+
+### copies the data, creates a clone ###
+sub clone {
+    my $self = shift;
+    return bless { %$self }, ref $self;
+}
+
+sub _new_from_chunk {
+    my $class = shift;
+    my $chunk = shift or return;    # 512 bytes of tar header
+    my %hash  = @_;
+
+    ### filter any arguments on defined-ness of values.
+    ### this allows overriding from what the tar-header is saying
+    ### about this tar-entry. Particularly useful for @LongLink files
+    my %args  = map { $_ => $hash{$_} } grep { defined $hash{$_} } keys %hash;
+
+    ### makes it start at 0 actually... :) ###
+    my $i = -1;
+    my %entry = map {
+	my ($s,$v)=($tmpl->[++$i],$tmpl->[++$i]);	# cdrake
+	($_)=($_=~/^([^\0]*)/) unless($s eq 'size');	# cdrake
+	$s=> $v ? oct $_ : $_				# cdrake
+	# $tmpl->[++$i] => $tmpl->[++$i] ? oct $_ : $_	# removed by cdrake - mucks up binary sizes >8gb
+    } unpack( UNPACK, $chunk );				# cdrake
+    # } map { /^([^\0]*)/ } unpack( UNPACK, $chunk );	# old - replaced now by cdrake
+
+
+    if(substr($entry{'size'}, 0, 1) eq "\x80") {	# binary size extension for files >8gigs (> octal 77777777777777)	# cdrake
+      my @sz=unpack("aCSNN",$entry{'size'}); $entry{'size'}=$sz[4]+(2**32)*$sz[3]+$sz[2]*(2**64);	# Use the low 80 bits (should use the upper 15 as well, but as at year 2011, that seems unlikely to ever be needed - the numbers are just too big...) # cdrake
+    } else {	# cdrake
+      ($entry{'size'})=($entry{'size'}=~/^([^\0]*)/); $entry{'size'}=oct $entry{'size'};	# cdrake
+    }	# cdrake
+
+
+    my $obj = bless { %entry, %args }, $class;
+
+	### magic is a filetype string.. it should have something like 'ustar' or
+	### something similar... if the chunk is garbage, skip it
+	return unless $obj->magic !~ /\W/;
+
+    ### store the original chunk ###
+    $obj->raw( $chunk );
+
+    $obj->type(FILE) if ( (!length $obj->type) or ($obj->type =~ /\W/) );
+    $obj->type(DIR)  if ( ($obj->is_file) && ($obj->name =~ m|/$|) );
+
+
+    return $obj;
+
+}
+
+sub _new_from_file {
+    my $class       = shift;
+    my $path        = shift;
+
+    ### path has to at least exist
+    return unless defined $path;
+
+    my $type        = __PACKAGE__->_filetype($path);
+    my $data        = '';
+
+    READ: {
+        unless ($type == DIR ) {
+            my $fh = IO::File->new;
+
+            unless( $fh->open($path) ) {
+                ### dangling symlinks are fine, stop reading but continue
+                ### creating the object
+                last READ if $type == SYMLINK;
+
+                ### otherwise, return from this function --
+                ### anything that's *not* a symlink should be
+                ### resolvable
+                return;
+            }
+
+            ### binmode needed to read files properly on win32 ###
+            binmode $fh;
+            $data = do { local $/; <$fh> };
+            close $fh;
+        }
+    }
+
+    my @items       = qw[mode uid gid size mtime];
+    my %hash        = map { shift(@items), $_ } (lstat $path)[2,4,5,7,9];
+
+    if (ON_VMS) {
+        ### VMS has two UID modes, traditional and POSIX.  Normally POSIX is
+        ### not used.  We currently do not have an easy way to see if we are in
+        ### POSIX mode.  In traditional mode, the UID is actually the VMS UIC.
+        ### The VMS UIC has the upper 16 bits is the GID, which in many cases
+        ### the VMS UIC will be larger than 209715, the largest that TAR can
+        ### handle.  So for now, assume it is traditional if the UID is larger
+        ### than 0x10000.
+
+        if ($hash{uid} > 0x10000) {
+            $hash{uid} = $hash{uid} & 0xFFFF;
+        }
+
+        ### The file length from stat() is the physical length of the file
+        ### However the amount of data read in may be more for some file types.
+        ### Fixed length files are read past the logical EOF to end of the block
+        ### containing.  Other file types get expanded on read because record
+        ### delimiters are added.
+
+        my $data_len = length $data;
+        $hash{size} = $data_len if $hash{size} < $data_len;
+
+    }
+    ### you *must* set size == 0 on symlinks, or the next entry will be
+    ### though of as the contents of the symlink, which is wrong.
+    ### this fixes bug #7937
+    $hash{size}     = 0 if ($type == DIR or $type == SYMLINK);
+    $hash{mtime}    -= TIME_OFFSET;
+
+    ### strip the high bits off the mode, which we don't need to store
+    $hash{mode}     = STRIP_MODE->( $hash{mode} );
+
+
+    ### probably requires some file path munging here ... ###
+    ### name and prefix are set later
+    my $obj = {
+        %hash,
+        name        => '',
+        chksum      => CHECK_SUM,
+        type        => $type,
+        linkname    => ($type == SYMLINK and CAN_READLINK)
+                            ? readlink $path
+                            : '',
+        magic       => MAGIC,
+        version     => TAR_VERSION,
+        uname       => UNAME->( $hash{uid} ),
+        gname       => GNAME->( $hash{gid} ),
+        devmajor    => 0,   # not handled
+        devminor    => 0,   # not handled
+        prefix      => '',
+        data        => $data,
+    };
+
+    bless $obj, $class;
+
+    ### fix up the prefix and file from the path
+    my($prefix,$file) = $obj->_prefix_and_file( $path );
+    $obj->prefix( $prefix );
+    $obj->name( $file );
+
+    return $obj;
+}
+
+sub _new_from_data {
+    my $class   = shift;
+    my $path    = shift;    return unless defined $path;
+    my $data    = shift;    return unless defined $data;
+    my $opt     = shift;
+
+    my $obj = {
+        data        => $data,
+        name        => '',
+        mode        => MODE,
+        uid         => UID,
+        gid         => GID,
+        size        => length $data,
+        mtime       => time - TIME_OFFSET,
+        chksum      => CHECK_SUM,
+        type        => FILE,
+        linkname    => '',
+        magic       => MAGIC,
+        version     => TAR_VERSION,
+        uname       => UNAME->( UID ),
+        gname       => GNAME->( GID ),
+        devminor    => 0,
+        devmajor    => 0,
+        prefix      => '',
+    };
+
+    ### overwrite with user options, if provided ###
+    if( $opt and ref $opt eq 'HASH' ) {
+        for my $key ( keys %$opt ) {
+
+            ### don't write bogus options ###
+            next unless exists $obj->{$key};
+            $obj->{$key} = $opt->{$key};
+        }
+    }
+
+    bless $obj, $class;
+
+    ### fix up the prefix and file from the path
+    my($prefix,$file) = $obj->_prefix_and_file( $path );
+    $obj->prefix( $prefix );
+    $obj->name( $file );
+
+    return $obj;
+}
+
+sub _prefix_and_file {
+    my $self = shift;
+    my $path = shift;
+
+    my ($vol, $dirs, $file) = File::Spec->splitpath( $path, $self->is_dir );
+    my @dirs = File::Spec->splitdir( File::Spec->canonpath($dirs) );
+
+    ### if it's a directory, then $file might be empty
+    $file = pop @dirs if $self->is_dir and not length $file;
+
+    ### splitting ../ gives you the relative path in native syntax
+    ### Remove the root (000000) directory
+    ### The volume from splitpath will also be in native syntax
+    if (ON_VMS) {
+        map { $_ = '..' if $_  eq '-'; $_ = '' if $_ eq '000000' } @dirs;
+        if (length($vol)) {
+            $vol = VMS::Filespec::unixify($vol);
+            unshift @dirs, $vol;
+        }
+    }
+
+    my $prefix = File::Spec::Unix->catdir(@dirs);
+    return( $prefix, $file );
+}
+
+sub _filetype {
+    my $self = shift;
+    my $file = shift;
+
+    return unless defined $file;
+
+    return SYMLINK  if (-l $file);	# Symlink
+
+    return FILE     if (-f _);		# Plain file
+
+    return DIR      if (-d _);		# Directory
+
+    return FIFO     if (-p _);		# Named pipe
+
+    return SOCKET   if (-S _);		# Socket
+
+    return BLOCKDEV if (-b _);		# Block special
+
+    return CHARDEV  if (-c _);		# Character special
+
+    ### shouldn't happen, this is when making archives, not reading ###
+    return LONGLINK if ( $file eq LONGLINK_NAME );
+
+    return UNKNOWN;		            # Something else (like what?)
+
+}
+
+### this method 'downgrades' a file to plain file -- this is used for
+### symlinks when FOLLOW_SYMLINKS is true.
+sub _downgrade_to_plainfile {
+    my $entry = shift;
+    $entry->type( FILE );
+    $entry->mode( MODE );
+    $entry->linkname('');
+
+    return 1;
+}
+
+=head2 $bool = $file->extract( [ $alternative_name ] )
+
+Extract this object, optionally to an alternative name.
+
+See C<< Archive::Tar->extract_file >> for details.
+
+Returns true on success and false on failure.
+
+=cut
+
+sub extract {
+    my $self = shift;
+
+    local $Carp::CarpLevel += 1;
+
+    return Archive::Tar->_extract_file( $self, @_ );
+}
+
+=head2 $path = $file->full_path
+
+Returns the full path from the tar header; this is basically a
+concatenation of the C<prefix> and C<name> fields.
+
+=cut
+
+sub full_path {
+    my $self = shift;
+
+    ### if prefix field is empty
+    return $self->name unless defined $self->prefix and length $self->prefix;
+
+    ### or otherwise, catfile'd
+    return File::Spec::Unix->catfile( $self->prefix, $self->name );
+}
+
+
+=head2 $bool = $file->validate
+
+Done by Archive::Tar internally when reading the tar file:
+validate the header against the checksum to ensure integer tar file.
+
+Returns true on success, false on failure
+
+=cut
+
+sub validate {
+    my $self = shift;
+
+    my $raw = $self->raw;
+
+    ### don't know why this one is different from the one we /write/ ###
+    substr ($raw, 148, 8) = "        ";
+
+    ### bug #43513: [PATCH] Accept wrong checksums from SunOS and HP-UX tar
+    ### like GNU tar does. See here for details:
+    ### http://www.gnu.org/software/tar/manual/tar.html#SEC139
+    ### so we do both a signed AND unsigned validate. if one succeeds, that's
+    ### good enough
+	return (   (unpack ("%16C*", $raw) == $self->chksum)
+	        or (unpack ("%16c*", $raw) == $self->chksum)) ? 1 : 0;
+}
+
+=head2 $bool = $file->has_content
+
+Returns a boolean to indicate whether the current object has content.
+Some special files like directories and so on never will have any
+content. This method is mainly to make sure you don't get warnings
+for using uninitialized values when looking at an object's content.
+
+=cut
+
+sub has_content {
+    my $self = shift;
+    return defined $self->data() && length $self->data() ? 1 : 0;
+}
+
+=head2 $content = $file->get_content
+
+Returns the current content for the in-memory file
+
+=cut
+
+sub get_content {
+    my $self = shift;
+    $self->data( );
+}
+
+=head2 $cref = $file->get_content_by_ref
+
+Returns the current content for the in-memory file as a scalar
+reference. Normal users won't need this, but it will save memory if
+you are dealing with very large data files in your tar archive, since
+it will pass the contents by reference, rather than make a copy of it
+first.
+
+=cut
+
+sub get_content_by_ref {
+    my $self = shift;
+
+    return \$self->{data};
+}
+
+=head2 $bool = $file->replace_content( $content )
+
+Replace the current content of the file with the new content. This
+only affects the in-memory archive, not the on-disk version until
+you write it.
+
+Returns true on success, false on failure.
+
+=cut
+
+sub replace_content {
+    my $self = shift;
+    my $data = shift || '';
+
+    $self->data( $data );
+    $self->size( length $data );
+    return 1;
+}
+
+=head2 $bool = $file->rename( $new_name )
+
+Rename the current file to $new_name.
+
+Note that you must specify a Unix path for $new_name, since per tar
+standard, all files in the archive must be Unix paths.
+
+Returns true on success and false on failure.
+
+=cut
+
+sub rename {
+    my $self = shift;
+    my $path = shift;
+
+    return unless defined $path;
+
+    my ($prefix,$file) = $self->_prefix_and_file( $path );
+
+    $self->name( $file );
+    $self->prefix( $prefix );
+
+	return 1;
+}
+
+=head2 $bool = $file->chmod $mode)
+
+Change mode of $file to $mode. The mode can be a string or a number
+which is interpreted as octal whether or not a leading 0 is given.
+
+Returns true on success and false on failure.
+
+=cut
+
+sub chmod {
+    my $self  = shift;
+    my $mode = shift; return unless defined $mode && $mode =~ /^[0-7]{1,4}$/;
+    $self->{mode} = oct($mode);
+    return 1;
+}
+
+=head2 $bool = $file->chown( $user [, $group])
+
+Change owner of $file to $user. If a $group is given that is changed
+as well. You can also pass a single parameter with a colon separating the
+use and group as in 'root:wheel'.
+
+Returns true on success and false on failure.
+
+=cut
+
+sub chown {
+    my $self = shift;
+    my $uname = shift;
+    return unless defined $uname;
+    my $gname;
+    if (-1 != index($uname, ':')) {
+	($uname, $gname) = split(/:/, $uname);
+    } else {
+	$gname = shift if @_ > 0;
+    }
+
+    $self->uname( $uname );
+    $self->gname( $gname ) if $gname;
+	return 1;
+}
+
+=head1 Convenience methods
+
+To quickly check the type of a C<Archive::Tar::File> object, you can
+use the following methods:
+
+=over 4
+
+=item $file->is_file
+
+Returns true if the file is of type C<file>
+
+=item $file->is_dir
+
+Returns true if the file is of type C<dir>
+
+=item $file->is_hardlink
+
+Returns true if the file is of type C<hardlink>
+
+=item $file->is_symlink
+
+Returns true if the file is of type C<symlink>
+
+=item $file->is_chardev
+
+Returns true if the file is of type C<chardev>
+
+=item $file->is_blockdev
+
+Returns true if the file is of type C<blockdev>
+
+=item $file->is_fifo
+
+Returns true if the file is of type C<fifo>
+
+=item $file->is_socket
+
+Returns true if the file is of type C<socket>
+
+=item $file->is_longlink
+
+Returns true if the file is of type C<LongLink>.
+Should not happen after a successful C<read>.
+
+=item $file->is_label
+
+Returns true if the file is of type C<Label>.
+Should not happen after a successful C<read>.
+
+=item $file->is_unknown
+
+Returns true if the file type is C<unknown>
+
+=back
+
+=cut
+
+#stupid perl5.5.3 needs to warn if it's not numeric
+sub is_file     { local $^W;    FILE      == $_[0]->type }
+sub is_dir      { local $^W;    DIR       == $_[0]->type }
+sub is_hardlink { local $^W;    HARDLINK  == $_[0]->type }
+sub is_symlink  { local $^W;    SYMLINK   == $_[0]->type }
+sub is_chardev  { local $^W;    CHARDEV   == $_[0]->type }
+sub is_blockdev { local $^W;    BLOCKDEV  == $_[0]->type }
+sub is_fifo     { local $^W;    FIFO      == $_[0]->type }
+sub is_socket   { local $^W;    SOCKET    == $_[0]->type }
+sub is_unknown  { local $^W;    UNKNOWN   == $_[0]->type }
+sub is_longlink { local $^W;    LONGLINK  eq $_[0]->type }
+sub is_label    { local $^W;    LABEL     eq $_[0]->type }
+
+1;

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/CBuilder/Base.pm

@@ -0,0 +1,405 @@
+package ExtUtils::CBuilder::Base;
+use strict;
+use warnings;
+use File::Spec;
+use File::Basename;
+use Cwd ();
+use Config;
+use Text::ParseWords;
+use IPC::Cmd qw(can_run);
+use File::Temp qw(tempfile);
+
+our $VERSION = '0.280231'; # VERSION
+
+# More details about C/C++ compilers:
+# http://developers.sun.com/sunstudio/documentation/product/compiler.jsp
+# http://gcc.gnu.org/
+# http://publib.boulder.ibm.com/infocenter/comphelp/v101v121/index.jsp
+# http://msdn.microsoft.com/en-us/vstudio/default.aspx
+
+my %cc2cxx = (
+    # first line order is important to support wrappers like in pkgsrc
+    cc => [ 'c++', 'CC', 'aCC', 'cxx', ], # Sun Studio, HP ANSI C/C++ Compilers
+    gcc => [ 'g++' ], # GNU Compiler Collection
+    xlc => [ 'xlC' ], # IBM C/C++ Set, xlc without thread-safety
+    xlc_r => [ 'xlC_r' ], # IBM C/C++ Set, xlc with thread-safety
+    cl    => [ 'cl' ], # Microsoft Visual Studio
+);
+
+sub new {
+  my $class = shift;
+  my $self = bless {@_}, $class;
+
+  $self->{properties}{perl} = $class->find_perl_interpreter
+    or warn "Warning: Can't locate your perl binary";
+
+  while (my ($k,$v) = each %Config) {
+    $self->{config}{$k} = $v unless exists $self->{config}{$k};
+  }
+  $self->{config}{cc} = $ENV{CC} if defined $ENV{CC};
+  $self->{config}{ccflags} = join(" ", $self->{config}{ccflags}, $ENV{CFLAGS})
+     if defined $ENV{CFLAGS};
+  $self->{config}{cxx} = $ENV{CXX} if defined $ENV{CXX};
+  $self->{config}{cxxflags} = $ENV{CXXFLAGS} if defined $ENV{CXXFLAGS};
+  $self->{config}{ld} = $ENV{LD} if defined $ENV{LD};
+  $self->{config}{ldflags} = join(" ", $self->{config}{ldflags}, $ENV{LDFLAGS})
+     if defined $ENV{LDFLAGS};
+
+  unless ( exists $self->{config}{cxx} ) {
+
+    my ($ccbase, $ccpath, $ccsfx ) = fileparse($self->{config}{cc}, qr/\.[^.]*/);
+
+    ## If the path is just "cc", fileparse returns $ccpath as "./"
+    $ccpath = "" if $self->{config}{cc} =~ /^\Q$ccbase$ccsfx\E$/;
+      
+    foreach my $cxx (@{$cc2cxx{$ccbase}}) {
+      my $cxx1 = File::Spec->catfile( $ccpath, $cxx . $ccsfx);
+
+      if( can_run( $cxx1 ) ) {
+        $self->{config}{cxx} = $cxx1;
+	last;
+      }
+      my $cxx2 = $cxx . $ccsfx;
+
+      if( can_run( $cxx2 ) ) {
+        $self->{config}{cxx} = $cxx2;
+	last;
+      }
+
+      if( can_run( $cxx ) ) {
+        $self->{config}{cxx} = $cxx;
+	last;
+      }
+    }
+    unless ( exists $self->{config}{cxx} ) {
+      $self->{config}{cxx} = $self->{config}{cc};
+      my $cflags = $self->{config}{ccflags};
+      $self->{config}{cxxflags} = '-x c++';
+      $self->{config}{cxxflags} .= " $cflags" if defined $cflags;
+    }
+  }
+
+  return $self;
+}
+
+sub find_perl_interpreter {
+  my $perl;
+  File::Spec->file_name_is_absolute($perl = $^X)
+    or -f ($perl = $Config::Config{perlpath})
+    or ($perl = $^X); # XXX how about using IPC::Cmd::can_run here?
+  return $perl;
+}
+
+sub add_to_cleanup {
+  my $self = shift;
+  foreach (@_) {
+    $self->{files_to_clean}{$_} = 1;
+  }
+}
+
+sub cleanup {
+  my $self = shift;
+  foreach my $file (keys %{$self->{files_to_clean}}) {
+    unlink $file;
+  }
+}
+
+sub get_config {
+    return %{ $_[0]->{config} };
+}
+
+sub object_file {
+  my ($self, $filename) = @_;
+
+  # File name, minus the suffix
+  (my $file_base = $filename) =~ s/\.[^.]+$//;
+  return "$file_base$self->{config}{obj_ext}";
+}
+
+sub arg_include_dirs {
+  my $self = shift;
+  return map {"-I$_"} @_;
+}
+
+sub arg_nolink { '-c' }
+
+sub arg_object_file {
+  my ($self, $file) = @_;
+  return ('-o', $file);
+}
+
+sub arg_share_object_file {
+  my ($self, $file) = @_;
+  return ($self->split_like_shell($self->{config}{lddlflags}), '-o', $file);
+}
+
+sub arg_exec_file {
+  my ($self, $file) = @_;
+  return ('-o', $file);
+}
+
+sub arg_defines {
+  my ($self, %args) = @_;
+  return map "-D$_=$args{$_}", sort keys %args;
+}
+
+sub compile {
+  my ($self, %args) = @_;
+  die "Missing 'source' argument to compile()" unless defined $args{source};
+
+  my $cf = $self->{config}; # For convenience
+
+  my $object_file = $args{object_file}
+    ? $args{object_file}
+    : $self->object_file($args{source});
+
+  my $include_dirs_ref =
+    (exists($args{include_dirs}) && ref($args{include_dirs}) ne "ARRAY")
+      ? [ $args{include_dirs} ]
+      : $args{include_dirs};
+  my @include_dirs = $self->arg_include_dirs(
+    @{ $include_dirs_ref || [] },
+    $self->perl_inc(),
+  );
+
+  my @defines = $self->arg_defines( %{$args{defines} || {}} );
+
+  my @extra_compiler_flags =
+    $self->split_like_shell($args{extra_compiler_flags});
+  my @cccdlflags = $self->split_like_shell($cf->{cccdlflags});
+  my @ccflags = $self->split_like_shell($args{'C++'} ? $cf->{cxxflags} : $cf->{ccflags});
+  my @optimize = $self->split_like_shell($cf->{optimize});
+  my @flags = (
+    @include_dirs,
+    @defines,
+    @cccdlflags,
+    @extra_compiler_flags,
+    $self->arg_nolink,
+    @ccflags,
+    @optimize,
+    $self->arg_object_file($object_file),
+  );
+  my @cc = $self->split_like_shell($args{'C++'} ? $cf->{cxx} : $cf->{cc});
+
+  $self->do_system(@cc, @flags, $args{source})
+    or die "error building $object_file from '$args{source}'";
+
+  return $object_file;
+}
+
+sub have_compiler {
+  my ($self, $is_cplusplus) = @_;
+  my $have_compiler_flag = $is_cplusplus ? "have_cxx" : "have_cc";
+  my $suffix = $is_cplusplus ? ".cc" : ".c";
+  return $self->{$have_compiler_flag} if defined $self->{$have_compiler_flag};
+
+  my $result;
+  my $attempts = 3;
+  # tmpdir has issues for some people so fall back to current dir
+
+  # don't clobber existing files (rare, but possible)
+  my ( $FH, $tmpfile ) = tempfile( "compilet-XXXXX", SUFFIX => $suffix );
+  binmode $FH;
+
+  if ( $is_cplusplus ) {
+    print $FH "class Bogus { public: int boot_compilet() { return 1; } };\n";
+  }
+  else {
+    print $FH "int boot_compilet() { return 1; }\n";
+  }
+  close $FH;
+
+  my ($obj_file, @lib_files);
+  eval {
+    local $^W = 0;
+    local $self->{quiet} = 1;
+    $obj_file = $self->compile('C++' => $is_cplusplus, source => $tmpfile);
+    @lib_files = $self->link(objects => $obj_file, module_name => 'compilet');
+  };
+  $result = $@ ? 0 : 1;
+
+  foreach (grep defined, $tmpfile, $obj_file, @lib_files) {
+    1 while unlink;
+  }
+
+  return $self->{$have_compiler_flag} = $result;
+}
+
+sub have_cplusplus {
+  push @_, 1;
+  goto &have_compiler;
+}
+
+sub lib_file {
+  my ($self, $dl_file, %args) = @_;
+  $dl_file =~ s/\.[^.]+$//;
+  $dl_file =~ tr/"//d;
+
+  if (defined $args{module_name} and length $args{module_name}) {
+    # Need to create with the same name as DynaLoader will load with.
+    require DynaLoader;
+    if (defined &DynaLoader::mod2fname) {
+      my $lib = DynaLoader::mod2fname([split /::/, $args{module_name}]);
+      my ($dev, $lib_dir, undef) = File::Spec->splitpath($dl_file);
+      $dl_file = File::Spec->catpath($dev, $lib_dir, $lib);
+    }
+  }
+
+  $dl_file .= ".$self->{config}{dlext}";
+
+  return $dl_file;
+}
+
+
+sub exe_file {
+  my ($self, $dl_file) = @_;
+  $dl_file =~ s/\.[^.]+$//;
+  $dl_file =~ tr/"//d;
+  return "$dl_file$self->{config}{_exe}";
+}
+
+sub need_prelink { 0 }
+
+sub extra_link_args_after_prelink { return }
+
+sub prelink {
+  my ($self, %args) = @_;
+
+  my ($dl_file_out, $mksymlists_args) = _prepare_mksymlists_args(\%args);
+
+  require ExtUtils::Mksymlists;
+  # dl. abbrev for dynamic library
+  ExtUtils::Mksymlists::Mksymlists( %{ $mksymlists_args } );
+
+  # Mksymlists will create one of these files
+  return grep -e, map "$dl_file_out.$_", qw(ext def opt);
+}
+
+sub _prepare_mksymlists_args {
+  my $args = shift;
+  ($args->{dl_file} = $args->{dl_name}) =~ s/.*::// unless $args->{dl_file};
+
+  my %mksymlists_args = (
+    DL_VARS  => $args->{dl_vars}      || [],
+    DL_FUNCS => $args->{dl_funcs}     || {},
+    FUNCLIST => $args->{dl_func_list} || [],
+    IMPORTS  => $args->{dl_imports}   || {},
+    NAME     => $args->{dl_name},    # Name of the Perl module
+    DLBASE   => $args->{dl_base},    # Basename of DLL file
+    FILE     => $args->{dl_file},    # Dir + Basename of symlist file
+    VERSION  => (defined $args->{dl_version} ? $args->{dl_version} : '0.0'),
+  );
+  return ($args->{dl_file}, \%mksymlists_args);
+}
+
+sub link {
+  my ($self, %args) = @_;
+  return $self->_do_link('lib_file', lddl => 1, %args);
+}
+
+sub link_executable {
+  my ($self, %args) = @_;
+  return $self->_do_link('exe_file', lddl => 0, %args);
+}
+
+sub _do_link {
+  my ($self, $type, %args) = @_;
+
+  my $cf = $self->{config}; # For convenience
+
+  my $objects = delete $args{objects};
+  $objects = [$objects] unless ref $objects;
+  my $out = $args{$type} || $self->$type($objects->[0], %args);
+
+  my @temp_files;
+  @temp_files =
+    $self->prelink(%args, dl_name => $args{module_name})
+      if $args{lddl} && $self->need_prelink;
+
+  my @linker_flags = (
+    $self->split_like_shell($args{extra_linker_flags}),
+    $self->extra_link_args_after_prelink(
+       %args, dl_name => $args{module_name}, prelink_res => \@temp_files
+    )
+  );
+
+  my @output = $args{lddl}
+    ? $self->arg_share_object_file($out)
+    : $self->arg_exec_file($out);
+  my @shrp = $self->split_like_shell($cf->{shrpenv});
+  my @ld = $self->split_like_shell($cf->{ld});
+
+  $self->do_system(@shrp, @ld, @output, @$objects, @linker_flags)
+    or die "error building $out from @$objects";
+
+  return wantarray ? ($out, @temp_files) : $out;
+}
+
+
+sub do_system {
+  my ($self, @cmd) = @_;
+  print "@cmd\n" if !$self->{quiet};
+  return !system(@cmd);
+}
+
+sub split_like_shell {
+  my ($self, $string) = @_;
+
+  return () unless defined($string);
+  return @$string if UNIVERSAL::isa($string, 'ARRAY');
+  $string =~ s/^\s+|\s+$//g;
+  return () unless length($string);
+
+  # Text::ParseWords replaces all 'escaped' characters with themselves, which completely
+  # breaks paths under windows. As such, we forcibly replace backwards slashes with forward
+  # slashes on windows.
+  $string =~ s@\\@/@g if $^O eq 'MSWin32';
+
+  return Text::ParseWords::shellwords($string);
+}
+
+# if building perl, perl's main source directory
+sub perl_src {
+  # N.B. makemaker actually searches regardless of PERL_CORE, but
+  # only squawks at not finding it if PERL_CORE is set
+
+  return unless $ENV{PERL_CORE};
+
+  my $Updir = File::Spec->updir;
+  my $dir   = File::Spec->curdir;
+
+  # Try up to 5 levels upwards
+  for (0..10) {
+    if (
+      -f File::Spec->catfile($dir,"config_h.SH")
+      &&
+      -f File::Spec->catfile($dir,"perl.h")
+      &&
+      -f File::Spec->catfile($dir,"lib","Exporter.pm")
+    ) {
+      return Cwd::realpath( $dir );
+    }
+
+    $dir = File::Spec->catdir($dir, $Updir);
+  }
+
+  warn "PERL_CORE is set but I can't find your perl source!\n";
+  return ''; # return empty string if $ENV{PERL_CORE} but can't find dir ???
+}
+
+# directory of perl's include files
+sub perl_inc {
+  my $self = shift;
+
+  $self->perl_src() || File::Spec->catdir($self->{config}{archlibexp},"CORE");
+}
+
+sub DESTROY {
+  my $self = shift;
+  local($., $@, $!, $^E, $?);
+  $self->cleanup();
+}
+
+1;
+
+# vim: ts=2 sw=2 et:

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/CBuilder/Platform/Unix.pm

@@ -0,0 +1,40 @@
+package ExtUtils::CBuilder::Platform::Unix;
+
+use warnings;
+use strict;
+use ExtUtils::CBuilder::Base;
+
+our $VERSION = '0.280231'; # VERSION
+our @ISA = qw(ExtUtils::CBuilder::Base);
+
+sub link_executable {
+  my $self = shift;
+
+  # On some platforms (which ones??) $Config{cc} seems to be a better
+  # bet for linking executables than $Config{ld}.  Cygwin is a notable
+  # exception.
+  local $self->{config}{ld} =
+    $self->{config}{cc} . " " . $self->{config}{ldflags};
+  return $self->SUPER::link_executable(@_);
+}
+
+sub link {
+  my $self = shift;
+  my $cf = $self->{config};
+
+  # Some platforms (notably Mac OS X 10.3, but some others too) expect
+  # the syntax "FOO=BAR /bin/command arg arg" to work in %Config
+  # (notably $Config{ld}).  It usually works in system(SCALAR), but we
+  # use system(LIST). We fix it up here with 'env'.
+
+  local $cf->{ld} = $cf->{ld};
+  if (ref $cf->{ld}) {
+    unshift @{$cf->{ld}}, 'env' if $cf->{ld}[0] =~ /^\s*\w+=/;
+  } else {
+    $cf->{ld} =~ s/^(\s*\w+=)/env $1/;
+  }
+
+  return $self->SUPER::link(@_);
+}
+
+1;

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/CBuilder/Platform/VMS.pm

@@ -0,0 +1,290 @@
+package ExtUtils::CBuilder::Platform::VMS;
+
+use warnings;
+use strict;
+use ExtUtils::CBuilder::Base;
+
+our $VERSION = '0.280231'; # VERSION
+our @ISA = qw(ExtUtils::CBuilder::Base);
+
+use File::Spec::Functions qw(catfile catdir);
+use Config;
+
+# We do prelink, but don't want the parent to redo it.
+
+sub need_prelink { 0 }
+
+sub arg_defines {
+  my ($self, %args) = @_;
+
+  s/"/""/g foreach values %args;
+
+  my @config_defines;
+
+  # VMS can only have one define qualifier; add the one from config, if any.
+  if ($self->{config}{ccflags} =~ s{/  def[^=]+  =+  \(?  ([^\/\)]*)  } {}ix) {
+    push @config_defines, $1;
+  }
+
+  return '' unless keys(%args) || @config_defines;
+
+  return ('/define=('
+          . join(',',
+		 @config_defines,
+                 map "\"$_" . ( length($args{$_}) ? "=$args{$_}" : '') . "\"",
+                     sort keys %args)
+          . ')');
+}
+
+sub arg_include_dirs {
+  my ($self, @dirs) = @_;
+
+  # VMS can only have one include list, add the one from config.
+  if ($self->{config}{ccflags} =~ s{/inc[^=]+(?:=)+(?:\()?([^\/\)]*)} {}i) {
+    unshift @dirs, $1;
+  }
+  return unless @dirs;
+
+  return ('/include=(' . join(',', @dirs) . ')');
+}
+
+# We override the compile method because we consume the includes and defines
+# parts of ccflags in the process of compiling but don't save those parts
+# anywhere, so $self->{config}{ccflags} needs to be reset for each compile
+# operation.
+
+sub compile {
+  my ($self, %args) = @_;
+
+  $self->{config}{ccflags} = $Config{ccflags};
+  $self->{config}{ccflags} = $ENV{CFLAGS} if defined $ENV{CFLAGS};
+
+  return $self->SUPER::compile(%args);
+}
+
+sub _do_link {
+  my ($self, $type, %args) = @_;
+
+  my $objects = delete $args{objects};
+  $objects = [$objects] unless ref $objects;
+
+  if ($args{lddl}) {
+
+    # prelink will call Mksymlists, which creates the extension-specific
+    # linker options file and populates it with the boot symbol.
+
+    my @temp_files = $self->prelink(%args, dl_name => $args{module_name});
+
+    # We now add the rest of what we need to the linker options file.  We
+    # should replicate the functionality of C<ExtUtils::MM_VMS::dlsyms>,
+    # but there is as yet no infrastructure for handling object libraries,
+    # so for now we depend on object files being listed individually on the
+    # command line, which should work for simple cases.  We do bring in our
+    # own version of C<ExtUtils::Liblist::Kid::ext> so that any additional
+    # libraries (including PERLSHR) can be added to the options file.
+
+    my @optlibs = $self->_liblist_ext( $args{'libs'} );
+
+    my $optfile = 'sys$disk:[]' . $temp_files[0];
+    open my $opt_fh, '>>', $optfile
+        or die "_do_link: Unable to open $optfile: $!";
+    for my $lib (@optlibs) {print $opt_fh "$lib\n" if length $lib }
+    close $opt_fh;
+
+    $objects->[-1] .= ',';
+    push @$objects, $optfile . '/OPTIONS,';
+
+    # This one not needed for DEC C, but leave for completeness.
+    push @$objects, $self->perl_inc() . 'perlshr_attr.opt/OPTIONS';
+  }
+
+  return $self->SUPER::_do_link($type, %args, objects => $objects);
+}
+
+sub arg_nolink { return; }
+
+sub arg_object_file {
+  my ($self, $file) = @_;
+  return "/obj=$file";
+}
+
+sub arg_exec_file {
+  my ($self, $file) = @_;
+  return ("/exe=$file");
+}
+
+sub arg_share_object_file {
+  my ($self, $file) = @_;
+  return ("$self->{config}{lddlflags}=$file");
+}
+
+# The following is reproduced almost verbatim from ExtUtils::Liblist::Kid::_vms_ext.
+# We can't just call that because it's tied up with the MakeMaker object hierarchy.
+
+sub _liblist_ext {
+  my($self, $potential_libs,$verbose,$give_libs) = @_;
+  $verbose ||= 0;
+
+  my(@crtls,$crtlstr);
+  @crtls = ( ($self->{'config'}{'ldflags'} =~ m-/Debug-i ? $self->{'config'}{'dbgprefix'} : '')
+              . 'PerlShr/Share' );
+  push(@crtls, grep { not /\(/ } split /\s+/, $self->{'config'}{'perllibs'});
+  push(@crtls, grep { not /\(/ } split /\s+/, $self->{'config'}{'libc'});
+  # In general, we pass through the basic libraries from %Config unchanged.
+  # The one exception is that if we're building in the Perl source tree, and
+  # a library spec could be resolved via a logical name, we go to some trouble
+  # to ensure that the copy in the local tree is used, rather than one to
+  # which a system-wide logical may point.
+  if ($self->perl_src) {
+    my($lib,$locspec,$type);
+    foreach $lib (@crtls) {
+      if (($locspec,$type) = $lib =~ m{^([\w\$-]+)(/\w+)?} and $locspec =~ /perl/i) {
+        if    (lc $type eq '/share')   { $locspec .= $self->{'config'}{'exe_ext'}; }
+        elsif (lc $type eq '/library') { $locspec .= $self->{'config'}{'lib_ext'}; }
+        else                           { $locspec .= $self->{'config'}{'obj_ext'}; }
+        $locspec = catfile($self->perl_src, $locspec);
+        $lib = "$locspec$type" if -e $locspec;
+      }
+    }
+  }
+  $crtlstr = @crtls ? join(' ',@crtls) : '';
+
+  unless ($potential_libs) {
+    warn "Result:\n\tEXTRALIBS: \n\tLDLOADLIBS: $crtlstr\n" if $verbose;
+    return ('', '', $crtlstr, '', ($give_libs ? [] : ()));
+  }
+
+  my(@dirs,@libs,$dir,$lib,%found,@fndlibs,$ldlib);
+  my $cwd = cwd();
+  my($so,$lib_ext,$obj_ext) = @{$self->{'config'}}{'so','lib_ext','obj_ext'};
+  # List of common Unix library names and their VMS equivalents
+  # (VMS equivalent of '' indicates that the library is automatically
+  # searched by the linker, and should be skipped here.)
+  my(@flibs, %libs_seen);
+  my %libmap = ( 'm' => '', 'f77' => '', 'F77' => '', 'V77' => '', 'c' => '',
+                 'malloc' => '', 'crypt' => '', 'resolv' => '', 'c_s' => '',
+                 'socket' => '', 'X11' => 'DECW$XLIBSHR',
+                 'Xt' => 'DECW$XTSHR', 'Xm' => 'DECW$XMLIBSHR',
+                 'Xmu' => 'DECW$XMULIBSHR');
+
+  warn "Potential libraries are '$potential_libs'\n" if $verbose;
+
+  # First, sort out directories and library names in the input
+  foreach $lib (split ' ',$potential_libs) {
+    push(@dirs,$1),   next if $lib =~ /^-L(.*)/;
+    push(@dirs,$lib), next if $lib =~ /[:>\]]$/;
+    push(@dirs,$lib), next if -d $lib;
+    push(@libs,$1),   next if $lib =~ /^-l(.*)/;
+    push(@libs,$lib);
+  }
+  push(@dirs,split(' ',$self->{'config'}{'libpth'}));
+
+  # Now make sure we've got VMS-syntax absolute directory specs
+  # (We don't, however, check whether someone's hidden a relative
+  # path in a logical name.)
+  foreach $dir (@dirs) {
+    unless (-d $dir) {
+      warn "Skipping nonexistent Directory $dir\n" if $verbose > 1;
+      $dir = '';
+      next;
+    }
+    warn "Resolving directory $dir\n" if $verbose;
+    if (!File::Spec->file_name_is_absolute($dir)) {
+        $dir = catdir($cwd,$dir);
+    }
+  }
+  @dirs = grep { length($_) } @dirs;
+  unshift(@dirs,''); # Check each $lib without additions first
+
+  LIB: foreach $lib (@libs) {
+    if (exists $libmap{$lib}) {
+      next unless length $libmap{$lib};
+      $lib = $libmap{$lib};
+    }
+
+    my(@variants,$variant,$cand);
+    my($ctype) = '';
+
+    # If we don't have a file type, consider it a possibly abbreviated name and
+    # check for common variants.  We try these first to grab libraries before
+    # a like-named executable image (e.g. -lperl resolves to perlshr.exe
+    # before perl.exe).
+    if ($lib !~ /\.[^:>\]]*$/) {
+      push(@variants,"${lib}shr","${lib}rtl","${lib}lib");
+      push(@variants,"lib$lib") if $lib !~ /[:>\]]/;
+    }
+    push(@variants,$lib);
+    warn "Looking for $lib\n" if $verbose;
+    foreach $variant (@variants) {
+      my($fullname, $name);
+
+      foreach $dir (@dirs) {
+        my($type);
+
+        $name = "$dir$variant";
+        warn "\tChecking $name\n" if $verbose > 2;
+        $fullname = VMS::Filespec::rmsexpand($name);
+        if (defined $fullname and -f $fullname) {
+          # It's got its own suffix, so we'll have to figure out the type
+          if    ($fullname =~ /(?:$so|exe)$/i)      { $type = 'SHR'; }
+          elsif ($fullname =~ /(?:$lib_ext|olb)$/i) { $type = 'OLB'; }
+          elsif ($fullname =~ /(?:$obj_ext|obj)$/i) {
+            warn "Note (probably harmless): "
+                ."Plain object file $fullname found in library list\n";
+            $type = 'OBJ';
+          }
+          else {
+            warn "Note (probably harmless): "
+                ."Unknown library type for $fullname; assuming shared\n";
+            $type = 'SHR';
+          }
+        }
+        elsif (-f ($fullname = VMS::Filespec::rmsexpand($name,$so))      or
+               -f ($fullname = VMS::Filespec::rmsexpand($name,'.exe')))     {
+          $type = 'SHR';
+          $name = $fullname unless $fullname =~ /exe;?\d*$/i;
+        }
+        elsif (not length($ctype) and  # If we've got a lib already,
+                                       # don't bother
+               ( -f ($fullname = VMS::Filespec::rmsexpand($name,$lib_ext)) or
+                 -f ($fullname = VMS::Filespec::rmsexpand($name,'.olb'))))  {
+          $type = 'OLB';
+          $name = $fullname unless $fullname =~ /olb;?\d*$/i;
+        }
+        elsif (not length($ctype) and  # If we've got a lib already,
+                                       # don't bother
+               ( -f ($fullname = VMS::Filespec::rmsexpand($name,$obj_ext)) or
+                 -f ($fullname = VMS::Filespec::rmsexpand($name,'.obj'))))  {
+          warn "Note (probably harmless): "
+		       ."Plain object file $fullname found in library list\n";
+          $type = 'OBJ';
+          $name = $fullname unless $fullname =~ /obj;?\d*$/i;
+        }
+        if (defined $type) {
+          $ctype = $type; $cand = $name;
+          last if $ctype eq 'SHR';
+        }
+      }
+      if ($ctype) {
+        push @{$found{$ctype}}, $cand;
+        warn "\tFound as $cand (really $fullname), type $ctype\n"
+          if $verbose > 1;
+	push @flibs, $name unless $libs_seen{$fullname}++;
+        next LIB;
+      }
+    }
+    warn "Note (probably harmless): "
+		 ."No library found for $lib\n";
+  }
+
+  push @fndlibs, @{$found{OBJ}}                      if exists $found{OBJ};
+  push @fndlibs, map { "$_/Library" } @{$found{OLB}} if exists $found{OLB};
+  push @fndlibs, map { "$_/Share"   } @{$found{SHR}} if exists $found{SHR};
+  $lib = join(' ',@fndlibs);
+
+  $ldlib = $crtlstr ? "$lib $crtlstr" : $lib;
+  warn "Result:\n\tEXTRALIBS: $lib\n\tLDLOADLIBS: $ldlib\n" if $verbose;
+  wantarray ? ($lib, '', $ldlib, '', ($give_libs ? \@flibs : ())) : $lib;
+}
+
+1;

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/CBuilder/Platform/android.pm

@@ -0,0 +1,39 @@
+package ExtUtils::CBuilder::Platform::android;
+
+use warnings;
+use strict;
+use File::Spec;
+use ExtUtils::CBuilder::Platform::Unix;
+use Config;
+
+our $VERSION = '0.280231'; # VERSION
+our @ISA = qw(ExtUtils::CBuilder::Platform::Unix);
+
+# The Android linker will not recognize symbols from
+# libperl unless the module explicitly depends on it.
+sub link {
+  my ($self, %args) = @_;
+
+  if ($self->{config}{useshrplib} eq 'true') {
+    $args{extra_linker_flags} = [
+      $self->split_like_shell($args{extra_linker_flags}),
+      '-L' . $self->perl_inc(),
+      '-lperl',
+      $self->split_like_shell($Config{perllibs}),
+    ];
+  }
+
+  # Several modules on CPAN rather rightfully expect being
+  # able to pass $so_file to DynaLoader::dl_load_file and
+  # have it Just Work.  However, $so_file will more likely
+  # than not be a relative path, and unless the module 
+  # author subclasses MakeMaker/Module::Build to modify
+  # LD_LIBRARY_PATH, which would be insane, Android's linker
+  # won't find the .so
+  # So we make this all work by returning an absolute path.
+  my($so_file, @so_tmps) = $self->SUPER::link(%args);
+  $so_file = File::Spec->rel2abs($so_file);
+  return wantarray ? ($so_file, @so_tmps) : $so_file;
+}
+
+1;

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/CBuilder/Platform/cygwin.pm

@@ -0,0 +1,33 @@
+package ExtUtils::CBuilder::Platform::cygwin;
+
+use warnings;
+use strict;
+use File::Spec;
+use ExtUtils::CBuilder::Platform::Unix;
+
+our $VERSION = '0.280231'; # VERSION
+our @ISA = qw(ExtUtils::CBuilder::Platform::Unix);
+
+# TODO: If a specific exe_file name is requested, if the exe created
+# doesn't have that name, we might want to rename it.  Apparently asking
+# for an exe of "foo" might result in "foo.exe".  Alternatively, we should
+# make sure the return value is correctly "foo.exe".
+# C.f http://rt.cpan.org/Public/Bug/Display.html?id=41003
+sub link_executable {
+  my $self = shift;
+  return $self->SUPER::link_executable(@_);
+}
+
+sub link {
+  my ($self, %args) = @_;
+
+  my $lib = $self->{config}{useshrplib} ? 'libperl.dll.a' : 'libperl.a';
+  $args{extra_linker_flags} = [
+    File::Spec->catfile($self->perl_inc(), $lib),
+    $self->split_like_shell($args{extra_linker_flags})
+  ];
+
+  return $self->SUPER::link(%args);
+}
+
+1;

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/CBuilder/Platform/darwin.pm

@@ -0,0 +1,22 @@
+package ExtUtils::CBuilder::Platform::darwin;
+
+use warnings;
+use strict;
+use ExtUtils::CBuilder::Platform::Unix;
+
+our $VERSION = '0.280231'; # VERSION
+our @ISA = qw(ExtUtils::CBuilder::Platform::Unix);
+
+sub compile {
+  my $self = shift;
+  my $cf = $self->{config};
+
+  # -flat_namespace isn't a compile flag, it's a linker flag.  But
+  # it's mistakenly in Config.pm as both.  Make the correction here.
+  local $cf->{ccflags} = $cf->{ccflags};
+  $cf->{ccflags} =~ s/-flat_namespace//;
+  $self->SUPER::compile(@_);
+}
+
+
+1;

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/Command/MM.pm

@@ -0,0 +1,323 @@
+package ExtUtils::Command::MM;
+
+require 5.006;
+
+use strict;
+use warnings;
+
+require Exporter;
+our @ISA = qw(Exporter);
+
+our @EXPORT  = qw(test_harness pod2man perllocal_install uninstall
+                  warn_if_old_packlist test_s cp_nonempty);
+our $VERSION = '7.34';
+$VERSION = eval $VERSION;
+
+my $Is_VMS = $^O eq 'VMS';
+
+sub mtime {
+  no warnings 'redefine';
+  local $@;
+  *mtime = (eval { require Time::HiRes } && defined &Time::HiRes::stat)
+    ? sub { (Time::HiRes::stat($_[0]))[9] }
+    : sub { (             stat($_[0]))[9] }
+  ;
+  goto &mtime;
+}
+
+=head1 NAME
+
+ExtUtils::Command::MM - Commands for the MM's to use in Makefiles
+
+=head1 SYNOPSIS
+
+  perl "-MExtUtils::Command::MM" -e "function" "--" arguments...
+
+
+=head1 DESCRIPTION
+
+B<FOR INTERNAL USE ONLY!>  The interface is not stable.
+
+ExtUtils::Command::MM encapsulates code which would otherwise have to
+be done with large "one" liners.
+
+Any $(FOO) used in the examples are make variables, not Perl.
+
+=over 4
+
+=item B<test_harness>
+
+  test_harness($verbose, @test_libs);
+
+Runs the tests on @ARGV via Test::Harness passing through the $verbose
+flag.  Any @test_libs will be unshifted onto the test's @INC.
+
+@test_libs are run in alphabetical order.
+
+=cut
+
+sub test_harness {
+    require Test::Harness;
+    require File::Spec;
+
+    $Test::Harness::verbose = shift;
+
+    # Because Windows doesn't do this for us and listing all the *.t files
+    # out on the command line can blow over its exec limit.
+    require ExtUtils::Command;
+    my @argv = ExtUtils::Command::expand_wildcards(@ARGV);
+
+    local @INC = @INC;
+    unshift @INC, map { File::Spec->rel2abs($_) } @_;
+    Test::Harness::runtests(sort { lc $a cmp lc $b } @argv);
+}
+
+
+
+=item B<pod2man>
+
+  pod2man( '--option=value',
+           $podfile1 => $manpage1,
+           $podfile2 => $manpage2,
+           ...
+         );
+
+  # or args on @ARGV
+
+pod2man() is a function performing most of the duties of the pod2man
+program.  Its arguments are exactly the same as pod2man as of 5.8.0
+with the addition of:
+
+    --perm_rw   octal permission to set the resulting manpage to
+
+And the removal of:
+
+    --verbose/-v
+    --help/-h
+
+If no arguments are given to pod2man it will read from @ARGV.
+
+If Pod::Man is unavailable, this function will warn and return undef.
+
+=cut
+
+sub pod2man {
+    local @ARGV = @_ ? @_ : @ARGV;
+
+    {
+        local $@;
+        if( !eval { require Pod::Man } ) {
+            warn "Pod::Man is not available: $@".
+                 "Man pages will not be generated during this install.\n";
+            return 0;
+        }
+    }
+    require Getopt::Long;
+
+    # We will cheat and just use Getopt::Long.  We fool it by putting
+    # our arguments into @ARGV.  Should be safe.
+    my %options = ();
+    Getopt::Long::config ('bundling_override');
+    Getopt::Long::GetOptions (\%options,
+                'section|s=s', 'release|r=s', 'center|c=s',
+                'date|d=s', 'fixed=s', 'fixedbold=s', 'fixeditalic=s',
+                'fixedbolditalic=s', 'official|o', 'quotes|q=s', 'lax|l',
+                'name|n=s', 'perm_rw=i', 'utf8|u'
+    );
+    delete $options{utf8} unless $Pod::Man::VERSION >= 2.17;
+
+    # If there's no files, don't bother going further.
+    return 0 unless @ARGV;
+
+    # Official sets --center, but don't override things explicitly set.
+    if ($options{official} && !defined $options{center}) {
+        $options{center} = q[Perl Programmer's Reference Guide];
+    }
+
+    # This isn't a valid Pod::Man option and is only accepted for backwards
+    # compatibility.
+    delete $options{lax};
+    my $count = scalar @ARGV / 2;
+    my $plural = $count == 1 ? 'document' : 'documents';
+    print "Manifying $count pod $plural\n";
+
+    do {{  # so 'next' works
+        my ($pod, $man) = splice(@ARGV, 0, 2);
+
+        next if ((-e $man) &&
+                 (mtime($man) > mtime($pod)) &&
+                 (mtime($man) > mtime("Makefile")));
+
+        my $parser = Pod::Man->new(%options);
+        $parser->parse_from_file($pod, $man)
+          or do { warn("Could not install $man\n");  next };
+
+        if (exists $options{perm_rw}) {
+            chmod(oct($options{perm_rw}), $man)
+              or do { warn("chmod $options{perm_rw} $man: $!\n"); next };
+        }
+    }} while @ARGV;
+
+    return 1;
+}
+
+
+=item B<warn_if_old_packlist>
+
+  perl "-MExtUtils::Command::MM" -e warn_if_old_packlist <somefile>
+
+Displays a warning that an old packlist file was found.  Reads the
+filename from @ARGV.
+
+=cut
+
+sub warn_if_old_packlist {
+    my $packlist = $ARGV[0];
+
+    return unless -f $packlist;
+    print <<"PACKLIST_WARNING";
+WARNING: I have found an old package in
+    $packlist.
+Please make sure the two installations are not conflicting
+PACKLIST_WARNING
+
+}
+
+
+=item B<perllocal_install>
+
+    perl "-MExtUtils::Command::MM" -e perllocal_install
+        <type> <module name> <key> <value> ...
+
+    # VMS only, key|value pairs come on STDIN
+    perl "-MExtUtils::Command::MM" -e perllocal_install
+        <type> <module name> < <key>|<value> ...
+
+Prints a fragment of POD suitable for appending to perllocal.pod.
+Arguments are read from @ARGV.
+
+'type' is the type of what you're installing.  Usually 'Module'.
+
+'module name' is simply the name of your module.  (Foo::Bar)
+
+Key/value pairs are extra information about the module.  Fields include:
+
+    installed into      which directory your module was out into
+    LINKTYPE            dynamic or static linking
+    VERSION             module version number
+    EXE_FILES           any executables installed in a space separated
+                        list
+
+=cut
+
+sub perllocal_install {
+    my($type, $name) = splice(@ARGV, 0, 2);
+
+    # VMS feeds args as a piped file on STDIN since it usually can't
+    # fit all the args on a single command line.
+    my @mod_info = $Is_VMS ? split /\|/, <STDIN>
+                           : @ARGV;
+
+    my $pod;
+    my $time = gmtime($ENV{SOURCE_DATE_EPOCH} || time);
+    $pod = sprintf <<'POD', scalar($time), $type, $name, $name;
+ =head2 %s: C<%s> L<%s|%s>
+
+ =over 4
+
+POD
+
+    do {
+        my($key, $val) = splice(@mod_info, 0, 2);
+
+        $pod .= <<POD
+ =item *
+
+ C<$key: $val>
+
+POD
+
+    } while(@mod_info);
+
+    $pod .= "=back\n\n";
+    $pod =~ s/^ //mg;
+    print $pod;
+
+    return 1;
+}
+
+=item B<uninstall>
+
+    perl "-MExtUtils::Command::MM" -e uninstall <packlist>
+
+A wrapper around ExtUtils::Install::uninstall().  Warns that
+uninstallation is deprecated and doesn't actually perform the
+uninstallation.
+
+=cut
+
+sub uninstall {
+    my($packlist) = shift @ARGV;
+
+    require ExtUtils::Install;
+
+    print <<'WARNING';
+
+Uninstall is unsafe and deprecated, the uninstallation was not performed.
+We will show what would have been done.
+
+WARNING
+
+    ExtUtils::Install::uninstall($packlist, 1, 1);
+
+    print <<'WARNING';
+
+Uninstall is unsafe and deprecated, the uninstallation was not performed.
+Please check the list above carefully, there may be errors.
+Remove the appropriate files manually.
+Sorry for the inconvenience.
+
+WARNING
+
+}
+
+=item B<test_s>
+
+   perl "-MExtUtils::Command::MM" -e test_s <file>
+
+Tests if a file exists and is not empty (size > 0).
+I<Exits> with 0 if it does, 1 if it does not.
+
+=cut
+
+sub test_s {
+  exit(-s $ARGV[0] ? 0 : 1);
+}
+
+=item B<cp_nonempty>
+
+  perl "-MExtUtils::Command::MM" -e cp_nonempty <srcfile> <dstfile> <perm>
+
+Tests if the source file exists and is not empty (size > 0). If it is not empty
+it copies it to the given destination with the given permissions.
+
+=back
+
+=cut
+
+sub cp_nonempty {
+  my @args = @ARGV;
+  return 0 unless -s $args[0];
+  require ExtUtils::Command;
+  {
+    local @ARGV = @args[0,1];
+    ExtUtils::Command::cp(@ARGV);
+  }
+  {
+    local @ARGV = @args[2,1];
+    ExtUtils::Command::chmod(@ARGV);
+  }
+}
+
+
+1;

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/Constant/Base.pm

@@ -0,0 +1,1019 @@
+package ExtUtils::Constant::Base;
+
+use strict;
+use vars qw($VERSION);
+use Carp;
+use Text::Wrap;
+use ExtUtils::Constant::Utils qw(C_stringify perl_stringify);
+$VERSION = '0.06';
+
+use constant is_perl56 => ($] < 5.007 && $] > 5.005_50);
+
+
+=head1 NAME
+
+ExtUtils::Constant::Base - base class for ExtUtils::Constant objects
+
+=head1 SYNOPSIS
+
+    require ExtUtils::Constant::Base;
+    @ISA = 'ExtUtils::Constant::Base';
+
+=head1 DESCRIPTION
+
+ExtUtils::Constant::Base provides a base implementation of methods to
+generate C code to give fast constant value lookup by named string. Currently
+it's mostly used ExtUtils::Constant::XS, which generates the lookup code
+for the constant() subroutine found in many XS modules.
+
+=head1 USAGE
+
+ExtUtils::Constant::Base exports no subroutines. The following methods are
+available
+
+=over 4
+
+=cut
+
+sub valid_type {
+  # Default to assuming that you don't need different types of return data.
+  1;
+}
+sub default_type {
+  '';
+}
+
+=item header
+
+A method returning a scalar containing definitions needed, typically for a
+C header file.
+
+=cut
+
+sub header {
+  ''
+}
+
+# This might actually be a return statement. Note that you are responsible
+# for any space you might need before your value, as it lets to perform
+# "tricks" such as "return KEY_" and have strings appended.
+sub assignment_clause_for_type;
+# In which case this might be an empty string
+sub return_statement_for_type {undef};
+sub return_statement_for_notdef;
+sub return_statement_for_notfound;
+
+# "#if 1" is true to a C pre-processor
+sub macro_from_name {
+  1;
+}
+
+sub macro_from_item {
+  1;
+}
+
+sub macro_to_ifdef {
+    my ($self, $macro) = @_;
+    if (ref $macro) {
+	return $macro->[0];
+    }
+    if (defined $macro && $macro ne "" && $macro ne "1") {
+	return $macro ? "#ifdef $macro\n" : "#if 0\n";
+    }
+    return "";
+}
+
+sub macro_to_ifndef {
+    my ($self, $macro) = @_;
+    if (ref $macro) {
+	# Can't invert these stylishly, so "bodge it"
+	return "$macro->[0]#else\n";
+    }
+    if (defined $macro && $macro ne "" && $macro ne "1") {
+	return $macro ? "#ifndef $macro\n" : "#if 1\n";
+    }
+    croak "Can't generate an ifndef for unconditional code";
+}
+
+sub macro_to_endif {
+    my ($self, $macro) = @_;
+
+    if (ref $macro) {
+	return $macro->[1];
+    }
+    if (defined $macro && $macro ne "" && $macro ne "1") {
+	return "#endif\n";
+    }
+    return "";
+}
+
+sub name_param {
+  'name';
+}
+
+# This is possibly buggy, in that it's not mandatory (below, in the main
+# C_constant parameters, but is expected to exist here, if it's needed)
+# Buggy because if you're definitely pure 8 bit only, and will never be
+# presented with your constants in utf8, the default form of C_constant can't
+# be told not to do the utf8 version.
+
+sub is_utf8_param {
+  'utf8';
+}
+
+sub memEQ {
+  "!memcmp";
+}
+
+=item memEQ_clause args_hashref
+
+A method to return a suitable C C<if> statement to check whether I<name>
+is equal to the C variable C<name>. If I<checked_at> is defined, then it
+is used to avoid C<memEQ> for short names, or to generate a comment to
+highlight the position of the character in the C<switch> statement.
+
+If i<checked_at> is a reference to a scalar, then instead it gives
+the characters pre-checked at the beginning, (and the number of chars by
+which the C variable name has been advanced. These need to be chopped from
+the front of I<name>).
+
+=cut
+
+sub memEQ_clause {
+#    if (memEQ(name, "thingy", 6)) {
+  # Which could actually be a character comparison or even ""
+  my ($self, $args) = @_;
+  my ($name, $checked_at, $indent) = @{$args}{qw(name checked_at indent)};
+  $indent = ' ' x ($indent || 4);
+  my $front_chop;
+  if (ref $checked_at) {
+    # regexp won't work on 5.6.1 without use utf8; in turn that won't work
+    # on 5.005_03.
+    substr ($name, 0, length $$checked_at,) = '';
+    $front_chop = C_stringify ($$checked_at);
+    undef $checked_at;
+  }
+  my $len = length $name;
+
+  if ($len < 2) {
+    return $indent . "{\n"
+	if (defined $checked_at and $checked_at == 0) or $len == 0;
+    # We didn't switch, drop through to the code for the 2 character string
+    $checked_at = 1;
+  }
+
+  my $name_param = $self->name_param;
+
+  if ($len < 3 and defined $checked_at) {
+    my $check;
+    if ($checked_at == 1) {
+      $check = 0;
+    } elsif ($checked_at == 0) {
+      $check = 1;
+    }
+    if (defined $check) {
+      my $char = C_stringify (substr $name, $check, 1);
+      # Placate 5.005 with a break in the string. I can't see a good way of
+      # getting it to not take [ as introducing an array lookup, even with
+      # ${name_param}[$check]
+      return $indent . "if ($name_param" . "[$check] == '$char') {\n";
+    }
+  }
+  if (($len == 2 and !defined $checked_at)
+     or ($len == 3 and defined ($checked_at) and $checked_at == 2)) {
+    my $char1 = C_stringify (substr $name, 0, 1);
+    my $char2 = C_stringify (substr $name, 1, 1);
+    return $indent .
+      "if ($name_param" . "[0] == '$char1' && $name_param" . "[1] == '$char2') {\n";
+  }
+  if (($len == 3 and defined ($checked_at) and $checked_at == 1)) {
+    my $char1 = C_stringify (substr $name, 0, 1);
+    my $char2 = C_stringify (substr $name, 2, 1);
+    return $indent .
+      "if ($name_param" . "[0] == '$char1' && $name_param" . "[2] == '$char2') {\n";
+  }
+
+  my $pointer = '^';
+  my $have_checked_last = defined ($checked_at) && $len == $checked_at + 1;
+  if ($have_checked_last) {
+    # Checked at the last character, so no need to memEQ it.
+    $pointer = C_stringify (chop $name);
+    $len--;
+  }
+
+  $name = C_stringify ($name);
+  my $memEQ = $self->memEQ();
+  my $body = $indent . "if ($memEQ($name_param, \"$name\", $len)) {\n";
+  # Put a little ^ under the letter we checked at
+  # Screws up for non printable and non-7 bit stuff, but that's too hard to
+  # get right.
+  if (defined $checked_at) {
+    $body .= $indent . "/*      " . (' ' x length $memEQ)
+      . (' ' x length $name_param)
+      . (' ' x $checked_at) . $pointer
+      . (' ' x ($len - $checked_at + length $len)) . "    */\n";
+  } elsif (defined $front_chop) {
+    $body .= $indent . "/*                $front_chop"
+      . (' ' x ($len + 1 + length $len)) . "    */\n";
+  }
+  return $body;
+}
+
+=item dump_names arg_hashref, ITEM...
+
+An internal function to generate the embedded perl code that will regenerate
+the constant subroutines.  I<default_type>, I<types> and I<ITEM>s are the
+same as for C_constant.  I<indent> is treated as number of spaces to indent
+by.  If C<declare_types> is true a C<$types> is always declared in the perl
+code generated, if defined and false never declared, and if undefined C<$types>
+is only declared if the values in I<types> as passed in cannot be inferred from
+I<default_types> and the I<ITEM>s.
+
+=cut
+
+sub dump_names {
+  my ($self, $args, @items) = @_;
+  my ($default_type, $what, $indent, $declare_types)
+    = @{$args}{qw(default_type what indent declare_types)};
+  $indent = ' ' x ($indent || 0);
+
+  my $result;
+  my (@simple, @complex, %used_types);
+  foreach (@items) {
+    my $type;
+    if (ref $_) {
+      $type = $_->{type} || $default_type;
+      if ($_->{utf8}) {
+        # For simplicity always skip the bytes case, and reconstitute this entry
+        # from its utf8 twin.
+        next if $_->{utf8} eq 'no';
+        # Copy the hashref, as we don't want to mess with the caller's hashref.
+        $_ = {%$_};
+        unless (is_perl56) {
+          utf8::decode ($_->{name});
+        } else {
+          $_->{name} = pack 'U*', unpack 'U0U*', $_->{name};
+        }
+        delete $_->{utf8};
+      }
+    } else {
+      $_ = {name=>$_};
+      $type = $default_type;
+    }
+    $used_types{$type}++;
+    if ($type eq $default_type
+        # grr 5.6.1
+        and length $_->{name}
+        and length $_->{name} == ($_->{name} =~ tr/A-Za-z0-9_//)
+        and !defined ($_->{macro}) and !defined ($_->{value})
+        and !defined ($_->{default}) and !defined ($_->{pre})
+        and !defined ($_->{post}) and !defined ($_->{def_pre})
+        and !defined ($_->{def_post}) and !defined ($_->{weight})) {
+      # It's the default type, and the name consists only of A-Za-z0-9_
+      push @simple, $_->{name};
+    } else {
+      push @complex, $_;
+    }
+  }
+
+  if (!defined $declare_types) {
+    # Do they pass in any types we weren't already using?
+    foreach (keys %$what) {
+      next if $used_types{$_};
+      $declare_types++; # Found one in $what that wasn't used.
+      last; # And one is enough to terminate this loop
+    }
+  }
+  if ($declare_types) {
+    $result = $indent . 'my $types = {map {($_, 1)} qw('
+      . join (" ", sort keys %$what) . ")};\n";
+  }
+  local $Text::Wrap::huge = 'overflow';
+  local $Text::Wrap::columns = 80;
+  $result .= wrap ($indent . "my \@names = (qw(",
+		   $indent . "               ", join (" ", sort @simple) . ")");
+  if (@complex) {
+    foreach my $item (sort {$a->{name} cmp $b->{name}} @complex) {
+      my $name = perl_stringify $item->{name};
+      my $line = ",\n$indent            {name=>\"$name\"";
+      $line .= ", type=>\"$item->{type}\"" if defined $item->{type};
+      foreach my $thing (qw (macro value default pre post def_pre def_post)) {
+        my $value = $item->{$thing};
+        if (defined $value) {
+          if (ref $value) {
+            $line .= ", $thing=>[\""
+              . join ('", "', map {perl_stringify $_} @$value) . '"]';
+          } else {
+            $line .= ", $thing=>\"" . perl_stringify($value) . "\"";
+          }
+        }
+      }
+      $line .= "}";
+      # Ensure that the enclosing C comment doesn't end
+      # by turning */  into *" . "/
+      $line =~ s!\*\/!\*" . "/!gs;
+      # gcc -Wall doesn't like finding /* inside a comment
+      $line =~ s!\/\*!/" . "\*!gs;
+      $result .= $line;
+    }
+  }
+  $result .= ");\n";
+
+  $result;
+}
+
+=item assign arg_hashref, VALUE...
+
+A method to return a suitable assignment clause. If I<type> is aggregate
+(eg I<PVN> expects both pointer and length) then there should be multiple
+I<VALUE>s for the components. I<pre> and I<post> if defined give snippets
+of C code to proceed and follow the assignment. I<pre> will be at the start
+of a block, so variables may be defined in it.
+
+=cut
+# Hmm. value undef to do NOTDEF? value () to do NOTFOUND?
+
+sub assign {
+  my $self = shift;
+  my $args = shift;
+  my ($indent, $type, $pre, $post, $item)
+      = @{$args}{qw(indent type pre post item)};
+  $post ||= '';
+  my $clause;
+  my $close;
+  if ($pre) {
+    chomp $pre;
+    $close = "$indent}\n";
+    $clause = $indent . "{\n";
+    $indent .= "  ";
+    $clause .= "$indent$pre";
+    $clause .= ";" unless $pre =~ /;$/;
+    $clause .= "\n";
+  }
+  confess "undef \$type" unless defined $type;
+  confess "Can't generate code for type $type"
+    unless $self->valid_type($type);
+
+  $clause .= join '', map {"$indent$_\n"}
+    $self->assignment_clause_for_type({type=>$type,item=>$item}, @_);
+  chomp $post;
+  if (length $post) {
+    $clause .= "$post";
+    $clause .= ";" unless $post =~ /;$/;
+    $clause .= "\n";
+  }
+  my $return = $self->return_statement_for_type($type);
+  $clause .= "$indent$return\n" if defined $return;
+  $clause .= $close if $close;
+  return $clause;
+}
+
+=item return_clause arg_hashref, ITEM
+
+A method to return a suitable C<#ifdef> clause. I<ITEM> is a hashref
+(as passed to C<C_constant> and C<match_clause>. I<indent> is the number
+of spaces to indent, defaulting to 6.
+
+=cut
+
+sub return_clause {
+
+##ifdef thingy
+#      *iv_return = thingy;
+#      return PERL_constant_ISIV;
+##else
+#      return PERL_constant_NOTDEF;
+##endif
+  my ($self, $args, $item) = @_;
+  my $indent = $args->{indent};
+
+  my ($name, $value, $default, $pre, $post, $def_pre, $def_post, $type)
+    = @$item{qw (name value default pre post def_pre def_post type)};
+  $value = $name unless defined $value;
+  my $macro = $self->macro_from_item($item);
+  $indent = ' ' x ($indent || 6);
+  unless (defined $type) {
+    # use Data::Dumper; print STDERR Dumper ($item);
+    confess "undef \$type";
+  }
+
+  ##ifdef thingy
+  my $clause = $self->macro_to_ifdef($macro);
+
+  #      *iv_return = thingy;
+  #      return PERL_constant_ISIV;
+  $clause
+    .= $self->assign ({indent=>$indent, type=>$type, pre=>$pre, post=>$post,
+		       item=>$item}, ref $value ? @$value : $value);
+
+  if (defined $macro && $macro ne "" && $macro ne "1") {
+    ##else
+    $clause .= "#else\n";
+
+    #      return PERL_constant_NOTDEF;
+    if (!defined $default) {
+      my $notdef = $self->return_statement_for_notdef();
+      $clause .= "$indent$notdef\n" if defined $notdef;
+    } else {
+      my @default = ref $default ? @$default : $default;
+      $type = shift @default;
+      $clause .= $self->assign ({indent=>$indent, type=>$type, pre=>$pre,
+				 post=>$post, item=>$item}, @default);
+    }
+  }
+  ##endif
+  $clause .= $self->macro_to_endif($macro);
+
+  return $clause;
+}
+
+sub match_clause {
+  # $offset defined if we have checked an offset.
+  my ($self, $args, $item) = @_;
+  my ($offset, $indent) = @{$args}{qw(checked_at indent)};
+  $indent = ' ' x ($indent || 4);
+  my $body = '';
+  my ($no, $yes, $either, $name, $inner_indent);
+  if (ref $item eq 'ARRAY') {
+    ($yes, $no) = @$item;
+    $either = $yes || $no;
+    confess "$item is $either expecting hashref in [0] || [1]"
+      unless ref $either eq 'HASH';
+    $name = $either->{name};
+  } else {
+    confess "$item->{name} has utf8 flag '$item->{utf8}', should be false"
+      if $item->{utf8};
+    $name = $item->{name};
+    $inner_indent = $indent;
+  }
+
+  $body .= $self->memEQ_clause ({name => $name, checked_at => $offset,
+				 indent => length $indent});
+  # If we've been presented with an arrayref for $item, then the user string
+  # contains in the range 128-255, and we need to check whether it was utf8
+  # (or not).
+  # In the worst case we have two named constants, where one's name happens
+  # encoded in UTF8 happens to be the same byte sequence as the second's
+  # encoded in (say) ISO-8859-1.
+  # In this case, $yes and $no both have item hashrefs.
+  if ($yes) {
+    $body .= $indent . "  if (" . $self->is_utf8_param . ") {\n";
+  } elsif ($no) {
+    $body .= $indent . "  if (!" . $self->is_utf8_param . ") {\n";
+  }
+  if ($either) {
+    $body .= $self->return_clause ({indent=>4 + length $indent}, $either);
+    if ($yes and $no) {
+      $body .= $indent . "  } else {\n";
+      $body .= $self->return_clause ({indent=>4 + length $indent}, $no);
+    }
+    $body .= $indent . "  }\n";
+  } else {
+    $body .= $self->return_clause ({indent=>2 + length $indent}, $item);
+  }
+  $body .= $indent . "}\n";
+}
+
+
+=item switch_clause arg_hashref, NAMELEN, ITEMHASH, ITEM...
+
+An internal method to generate a suitable C<switch> clause, called by
+C<C_constant> I<ITEM>s are in the hash ref format as given in the description
+of C<C_constant>, and must all have the names of the same length, given by
+I<NAMELEN>.  I<ITEMHASH> is a reference to a hash, keyed by name, values being
+the hashrefs in the I<ITEM> list.  (No parameters are modified, and there can
+be keys in the I<ITEMHASH> that are not in the list of I<ITEM>s without
+causing problems - the hash is passed in to save generating it afresh for
+each call).
+
+=cut
+
+sub switch_clause {
+  my ($self, $args, $namelen, $items, @items) = @_;
+  my ($indent, $comment) = @{$args}{qw(indent comment)};
+  $indent = ' ' x ($indent || 2);
+
+  local $Text::Wrap::huge = 'overflow';
+  local $Text::Wrap::columns = 80;
+
+  my @names = sort map {$_->{name}} @items;
+  my $leader = $indent . '/* ';
+  my $follower = ' ' x length $leader;
+  my $body = $indent . "/* Names all of length $namelen.  */\n";
+  if (defined $comment) {
+    $body = wrap ($leader, $follower, $comment) . "\n";
+    $leader = $follower;
+  }
+  my @safe_names = @names;
+  foreach (@safe_names) {
+    confess sprintf "Name '$_' is length %d, not $namelen", length
+      unless length == $namelen;
+    # Argh. 5.6.1
+    # next unless tr/A-Za-z0-9_//c;
+    next if tr/A-Za-z0-9_// == length;
+    $_ = '"' . perl_stringify ($_) . '"';
+    # Ensure that the enclosing C comment doesn't end
+    # by turning */  into *" . "/
+    s!\*\/!\*"."/!gs;
+    # gcc -Wall doesn't like finding /* inside a comment
+    s!\/\*!/"."\*!gs;
+  }
+  $body .= wrap ($leader, $follower, join (" ", @safe_names) . " */") . "\n";
+  # Figure out what to switch on.
+  # (RMS, Spread of jump table, Position, Hashref)
+  my @best = (1e38, ~0);
+  # Prefer the last character over the others. (As it lets us shorten the
+  # memEQ clause at no cost).
+  foreach my $i ($namelen - 1, 0 .. ($namelen - 2)) {
+    my ($min, $max) = (~0, 0);
+    my %spread;
+    if (is_perl56) {
+      # Need proper Unicode preserving hash keys for bytes in range 128-255
+      # here too, for some reason. grr 5.6.1 yet again.
+      tie %spread, 'ExtUtils::Constant::Aaargh56Hash';
+    }
+    foreach (@names) {
+      my $char = substr $_, $i, 1;
+      my $ord = ord $char;
+      confess "char $ord is out of range" if $ord > 255;
+      $max = $ord if $ord > $max;
+      $min = $ord if $ord < $min;
+      push @{$spread{$char}}, $_;
+      # warn "$_ $char";
+    }
+    # I'm going to pick the character to split on that minimises the root
+    # mean square of the number of names in each case. Normally this should
+    # be the one with the most keys, but it may pick a 7 where the 8 has
+    # one long linear search. I'm not sure if RMS or just sum of squares is
+    # actually better.
+    # $max and $min are for the tie-breaker if the root mean squares match.
+    # Assuming that the compiler may be building a jump table for the
+    # switch() then try to minimise the size of that jump table.
+    # Finally use < not <= so that if it still ties the earliest part of
+    # the string wins. Because if that passes but the memEQ fails, it may
+    # only need the start of the string to bin the choice.
+    # I think. But I'm micro-optimising. :-)
+    # OK. Trump that. Now favour the last character of the string, before the
+    # rest.
+    my $ss;
+    $ss += @$_ * @$_ foreach values %spread;
+    my $rms = sqrt ($ss / keys %spread);
+    if ($rms < $best[0] || ($rms == $best[0] && ($max - $min) < $best[1])) {
+      @best = ($rms, $max - $min, $i, \%spread);
+    }
+  }
+  confess "Internal error. Failed to pick a switch point for @names"
+    unless defined $best[2];
+  # use Data::Dumper; print Dumper (@best);
+  my ($offset, $best) = @best[2,3];
+  $body .= $indent . "/* Offset $offset gives the best switch position.  */\n";
+
+  my $do_front_chop = $offset == 0 && $namelen > 2;
+  if ($do_front_chop) {
+    $body .= $indent . "switch (*" . $self->name_param() . "++) {\n";
+  } else {
+    $body .= $indent . "switch (" . $self->name_param() . "[$offset]) {\n";
+  }
+  foreach my $char (sort keys %$best) {
+    confess sprintf "'$char' is %d bytes long, not 1", length $char
+      if length ($char) != 1;
+    confess sprintf "char %#X is out of range", ord $char if ord ($char) > 255;
+    $body .= $indent . "case '" . C_stringify ($char) . "':\n";
+    foreach my $thisone (sort {
+	# Deal with the case of an item actually being an array ref to 1 or 2
+	# hashrefs. Don't assign to $a or $b, as they're aliases to the
+        # original
+	my $l = ref $a eq 'ARRAY' ? ($a->[0] || $->[1]) : $a;
+	my $r = ref $b eq 'ARRAY' ? ($b->[0] || $->[1]) : $b;
+	# Sort by weight first
+	($r->{weight} || 0) <=> ($l->{weight} || 0)
+	    # Sort equal weights by name
+	    or $l->{name} cmp $r->{name}}
+			 # If this looks evil, maybe it is.  $items is a
+			 # hashref, and we're doing a hash slice on it
+			 @{$items}{@{$best->{$char}}}) {
+      # warn "You are here";
+      if ($do_front_chop) {
+        $body .= $self->match_clause ({indent => 2 + length $indent,
+				       checked_at => \$char}, $thisone);
+      } else {
+        $body .= $self->match_clause ({indent => 2 + length $indent,
+				       checked_at => $offset}, $thisone);
+      }
+    }
+    $body .= $indent . "  break;\n";
+  }
+  $body .= $indent . "}\n";
+  return $body;
+}
+
+sub C_constant_return_type {
+  "static int";
+}
+
+sub C_constant_prefix_param {
+  '';
+}
+
+sub C_constant_prefix_param_defintion {
+  '';
+}
+
+sub name_param_definition {
+  "const char *" . $_[0]->name_param;
+}
+
+sub namelen_param {
+  'len';
+}
+
+sub namelen_param_definition {
+  'size_t ' . $_[0]->namelen_param;
+}
+
+sub C_constant_other_params {
+  '';
+}
+
+sub C_constant_other_params_defintion {
+  '';
+}
+
+=item params WHAT
+
+An "internal" method, subject to change, currently called to allow an
+overriding class to cache information that will then be passed into all
+the C<*param*> calls. (Yes, having to read the source to make sense of this is
+considered a known bug). I<WHAT> is be a hashref of types the constant
+function will return. In ExtUtils::Constant::XS this method is used to
+returns a hashref keyed IV NV PV SV to show which combination of pointers will
+be needed in the C argument list generated by
+C_constant_other_params_definition and C_constant_other_params
+
+=cut
+
+sub params {
+  '';
+}
+
+
+=item dogfood arg_hashref, ITEM...
+
+An internal function to generate the embedded perl code that will regenerate
+the constant subroutines.  Parameters are the same as for C_constant.
+
+Currently the base class does nothing and returns an empty string.
+
+=cut
+
+sub dogfood {
+  ''
+}
+
+=item normalise_items args, default_type, seen_types, seen_items, ITEM...
+
+Convert the items to a normalised form. For 8 bit and Unicode values converts
+the item to an array of 1 or 2 items, both 8 bit and UTF-8 encoded.
+
+=cut
+
+sub normalise_items
+{
+    my $self = shift;
+    my $args = shift;
+    my $default_type = shift;
+    my $what = shift;
+    my $items = shift;
+    my @new_items;
+    foreach my $orig (@_) {
+	my ($name, $item);
+      if (ref $orig) {
+        # Make a copy which is a normalised version of the ref passed in.
+        $name = $orig->{name};
+        my ($type, $macro, $value) = @$orig{qw (type macro value)};
+        $type ||= $default_type;
+        $what->{$type} = 1;
+        $item = {name=>$name, type=>$type};
+
+        undef $macro if defined $macro and $macro eq $name;
+        $item->{macro} = $macro if defined $macro;
+        undef $value if defined $value and $value eq $name;
+        $item->{value} = $value if defined $value;
+        foreach my $key (qw(default pre post def_pre def_post weight
+			    not_constant)) {
+          my $value = $orig->{$key};
+          $item->{$key} = $value if defined $value;
+          # warn "$key $value";
+        }
+      } else {
+        $name = $orig;
+        $item = {name=>$name, type=>$default_type};
+        $what->{$default_type} = 1;
+      }
+      warn +(ref ($self) || $self)
+	. "doesn't know how to handle values of type $_ used in macro $name"
+	  unless $self->valid_type ($item->{type});
+      # tr///c is broken on 5.6.1 for utf8, so my original tr/\0-\177//c
+      # doesn't work. Upgrade to 5.8
+      # if ($name !~ tr/\0-\177//c || $] < 5.005_50) {
+      if ($name =~ tr/\0-\177// == length $name || $] < 5.005_50
+	 || $args->{disable_utf8_duplication}) {
+        # No characters outside 7 bit ASCII.
+        if (exists $items->{$name}) {
+          die "Multiple definitions for macro $name";
+        }
+        $items->{$name} = $item;
+      } else {
+        # No characters outside 8 bit. This is hardest.
+        if (exists $items->{$name} and ref $items->{$name} ne 'ARRAY') {
+          confess "Unexpected ASCII definition for macro $name";
+        }
+        # Again, 5.6.1 tr broken, so s/5\.6.*/5\.8\.0/;
+        # if ($name !~ tr/\0-\377//c) {
+        if ($name =~ tr/\0-\377// == length $name) {
+#          if ($] < 5.007) {
+#            $name = pack "C*", unpack "U*", $name;
+#          }
+          $item->{utf8} = 'no';
+          $items->{$name}[1] = $item;
+          push @new_items, $item;
+          # Copy item, to create the utf8 variant.
+          $item = {%$item};
+        }
+        # Encode the name as utf8 bytes.
+        unless (is_perl56) {
+          utf8::encode($name);
+        } else {
+#          warn "Was >$name< " . length ${name};
+          $name = pack 'C*', unpack 'C*', $name . pack 'U*';
+#          warn "Now '${name}' " . length ${name};
+        }
+        if ($items->{$name}[0]) {
+          die "Multiple definitions for macro $name";
+        }
+        $item->{utf8} = 'yes';
+        $item->{name} = $name;
+        $items->{$name}[0] = $item;
+        # We have need for the utf8 flag.
+        $what->{''} = 1;
+      }
+      push @new_items, $item;
+    }
+    @new_items;
+}
+
+=item C_constant arg_hashref, ITEM...
+
+A function that returns a B<list> of C subroutine definitions that return
+the value and type of constants when passed the name by the XS wrapper.
+I<ITEM...> gives a list of constant names. Each can either be a string,
+which is taken as a C macro name, or a reference to a hash with the following
+keys
+
+=over 8
+
+=item name
+
+The name of the constant, as seen by the perl code.
+
+=item type
+
+The type of the constant (I<IV>, I<NV> etc)
+
+=item value
+
+A C expression for the value of the constant, or a list of C expressions if
+the type is aggregate. This defaults to the I<name> if not given.
+
+=item macro
+
+The C pre-processor macro to use in the C<#ifdef>. This defaults to the
+I<name>, and is mainly used if I<value> is an C<enum>. If a reference an
+array is passed then the first element is used in place of the C<#ifdef>
+line, and the second element in place of the C<#endif>. This allows
+pre-processor constructions such as
+
+    #if defined (foo)
+    #if !defined (bar)
+    ...
+    #endif
+    #endif
+
+to be used to determine if a constant is to be defined.
+
+A "macro" 1 signals that the constant is always defined, so the C<#if>/C<#endif>
+test is omitted.
+
+=item default
+
+Default value to use (instead of C<croak>ing with "your vendor has not
+defined...") to return if the macro isn't defined. Specify a reference to
+an array with type followed by value(s).
+
+=item pre
+
+C code to use before the assignment of the value of the constant. This allows
+you to use temporary variables to extract a value from part of a C<struct>
+and return this as I<value>. This C code is places at the start of a block,
+so you can declare variables in it.
+
+=item post
+
+C code to place between the assignment of value (to a temporary) and the
+return from the function. This allows you to clear up anything in I<pre>.
+Rarely needed.
+
+=item def_pre
+
+=item def_post
+
+Equivalents of I<pre> and I<post> for the default value.
+
+=item utf8
+
+Generated internally. Is zero or undefined if name is 7 bit ASCII,
+"no" if the name is 8 bit (and so should only match if SvUTF8() is false),
+"yes" if the name is utf8 encoded.
+
+The internals automatically clone any name with characters 128-255 but none
+256+ (ie one that could be either in bytes or utf8) into a second entry
+which is utf8 encoded.
+
+=item weight
+
+Optional sorting weight for names, to determine the order of
+linear testing when multiple names fall in the same case of a switch clause.
+Higher comes earlier, undefined defaults to zero.
+
+=back
+
+In the argument hashref, I<package> is the name of the package, and is only
+used in comments inside the generated C code. I<subname> defaults to
+C<constant> if undefined.
+
+I<default_type> is the type returned by C<ITEM>s that don't specify their
+type. It defaults to the value of C<default_type()>. I<types> should be given
+either as a comma separated list of types that the C subroutine I<subname>
+will generate or as a reference to a hash. I<default_type> will be added to
+the list if not present, as will any types given in the list of I<ITEM>s. The
+resultant list should be the same list of types that C<XS_constant> is
+given. [Otherwise C<XS_constant> and C<C_constant> may differ in the number of
+parameters to the constant function. I<indent> is currently unused and
+ignored. In future it may be used to pass in information used to change the C
+indentation style used.]  The best way to maintain consistency is to pass in a
+hash reference and let this function update it.
+
+I<breakout> governs when child functions of I<subname> are generated.  If there
+are I<breakout> or more I<ITEM>s with the same length of name, then the code
+to switch between them is placed into a function named I<subname>_I<len>, for
+example C<constant_5> for names 5 characters long.  The default I<breakout> is
+3.  A single C<ITEM> is always inlined.
+
+=cut
+
+# The parameter now BREAKOUT was previously documented as:
+#
+# I<NAMELEN> if defined signals that all the I<name>s of the I<ITEM>s are of
+# this length, and that the constant name passed in by perl is checked and
+# also of this length. It is used during recursion, and should be C<undef>
+# unless the caller has checked all the lengths during code generation, and
+# the generated subroutine is only to be called with a name of this length.
+#
+# As you can see it now performs this function during recursion by being a
+# scalar reference.
+
+sub C_constant {
+  my ($self, $args, @items) = @_;
+  my ($package, $subname, $default_type, $what, $indent, $breakout) =
+    @{$args}{qw(package subname default_type types indent breakout)};
+  $package ||= 'Foo';
+  $subname ||= 'constant';
+  # I'm not using this. But a hashref could be used for full formatting without
+  # breaking this API
+  # $indent ||= 0;
+
+  my ($namelen, $items);
+  if (ref $breakout) {
+    # We are called recursively. We trust @items to be normalised, $what to
+    # be a hashref, and pinch %$items from our parent to save recalculation.
+    ($namelen, $items) = @$breakout;
+  } else {
+    $items = {};
+    if (is_perl56) {
+      # Need proper Unicode preserving hash keys.
+      require ExtUtils::Constant::Aaargh56Hash;
+      tie %$items, 'ExtUtils::Constant::Aaargh56Hash';
+    }
+    $breakout ||= 3;
+    $default_type ||= $self->default_type();
+    if (!ref $what) {
+      # Convert line of the form IV,UV,NV to hash
+      $what = {map {$_ => 1} split /,\s*/, ($what || '')};
+      # Figure out what types we're dealing with, and assign all unknowns to the
+      # default type
+    }
+    @items = $self->normalise_items ({}, $default_type, $what, $items, @items);
+    # use Data::Dumper; print Dumper @items;
+  }
+  my $params = $self->params ($what);
+
+  # Probably "static int"
+  my ($body, @subs);
+  $body = $self->C_constant_return_type($params) . "\n$subname ("
+    # Eg "pTHX_ "
+    . $self->C_constant_prefix_param_defintion($params)
+      # Probably "const char *name"
+      . $self->name_param_definition($params);
+  # Something like ", STRLEN len"
+  $body .= ", " . $self->namelen_param_definition($params)
+    unless defined $namelen;
+  $body .= $self->C_constant_other_params_defintion($params);
+  $body .= ") {\n";
+
+  if (defined $namelen) {
+    # We are a child subroutine. Print the simple description
+    my $comment = 'When generated this function returned values for the list'
+      . ' of names given here.  However, subsequent manual editing may have'
+        . ' added or removed some.';
+    $body .= $self->switch_clause ({indent=>2, comment=>$comment},
+				   $namelen, $items, @items);
+  } else {
+    # We are the top level.
+    $body .= "  /* Initially switch on the length of the name.  */\n";
+    $body .= $self->dogfood ({package => $package, subname => $subname,
+			      default_type => $default_type, what => $what,
+			      indent => $indent, breakout => $breakout},
+			     @items);
+    $body .= '  switch ('.$self->namelen_param().") {\n";
+    # Need to group names of the same length
+    my @by_length;
+    foreach (@items) {
+      push @{$by_length[length $_->{name}]}, $_;
+    }
+    foreach my $i (0 .. $#by_length) {
+      next unless $by_length[$i];	# None of this length
+      $body .= "  case $i:\n";
+      if (@{$by_length[$i]} == 1) {
+        my $only_thing = $by_length[$i]->[0];
+        if ($only_thing->{utf8}) {
+          if ($only_thing->{utf8} eq 'yes') {
+            # With utf8 on flag item is passed in element 0
+            $body .= $self->match_clause (undef, [$only_thing]);
+          } else {
+            # With utf8 off flag item is passed in element 1
+            $body .= $self->match_clause (undef, [undef, $only_thing]);
+          }
+        } else {
+          $body .= $self->match_clause (undef, $only_thing);
+        }
+      } elsif (@{$by_length[$i]} < $breakout) {
+        $body .= $self->switch_clause ({indent=>4},
+				       $i, $items, @{$by_length[$i]});
+      } else {
+        # Only use the minimal set of parameters actually needed by the types
+        # of the names of this length.
+        my $what = {};
+        foreach (@{$by_length[$i]}) {
+          $what->{$_->{type}} = 1;
+          $what->{''} = 1 if $_->{utf8};
+        }
+        $params = $self->params ($what);
+        push @subs, $self->C_constant ({package=>$package,
+					subname=>"${subname}_$i",
+					default_type => $default_type,
+					types => $what, indent => $indent,
+					breakout => [$i, $items]},
+				       @{$by_length[$i]});
+        $body .= "    return ${subname}_$i ("
+	  # Eg "aTHX_ "
+	  . $self->C_constant_prefix_param($params)
+	    # Probably "name"
+	    . $self->name_param($params);
+	$body .= $self->C_constant_other_params($params);
+        $body .= ");\n";
+      }
+      $body .= "    break;\n";
+    }
+    $body .= "  }\n";
+  }
+  my $notfound = $self->return_statement_for_notfound();
+  $body .= "  $notfound\n" if $notfound;
+  $body .= "}\n";
+  return (@subs, $body);
+}
+
+1;
+__END__
+
+=back
+
+=head1 BUGS
+
+Not everything is documented yet.
+
+Probably others.
+
+=head1 AUTHOR
+
+Nicholas Clark <[email protected]> based on the code in C<h2xs> by Larry Wall and
+others

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/Constant/ProxySubs.pm

@@ -0,0 +1,682 @@
+package ExtUtils::Constant::ProxySubs;
+
+use strict;
+use vars qw($VERSION @ISA %type_to_struct %type_from_struct %type_to_sv
+	    %type_to_C_value %type_is_a_problem %type_num_args
+	    %type_temporary);
+use Carp;
+require ExtUtils::Constant::XS;
+use ExtUtils::Constant::Utils qw(C_stringify);
+use ExtUtils::Constant::XS qw(%XS_TypeSet);
+
+$VERSION = '0.09';
+@ISA = 'ExtUtils::Constant::XS';
+
+%type_to_struct =
+    (
+     IV => '{const char *name; I32 namelen; IV value;}',
+     NV => '{const char *name; I32 namelen; NV value;}',
+     UV => '{const char *name; I32 namelen; UV value;}',
+     PV => '{const char *name; I32 namelen; const char *value;}',
+     PVN => '{const char *name; I32 namelen; const char *value; STRLEN len;}',
+     YES => '{const char *name; I32 namelen;}',
+     NO => '{const char *name; I32 namelen;}',
+     UNDEF => '{const char *name; I32 namelen;}',
+     '' => '{const char *name; I32 namelen;} ',
+     );
+
+%type_from_struct =
+    (
+     IV => sub { $_[0] . '->value' },
+     NV => sub { $_[0] . '->value' },
+     UV => sub { $_[0] . '->value' },
+     PV => sub { $_[0] . '->value' },
+     PVN => sub { $_[0] . '->value', $_[0] . '->len' },
+     YES => sub {},
+     NO => sub {},
+     UNDEF => sub {},
+     '' => sub {},
+    );
+
+%type_to_sv = 
+    (
+     IV => sub { "newSViv($_[0])" },
+     NV => sub { "newSVnv($_[0])" },
+     UV => sub { "newSVuv($_[0])" },
+     PV => sub { "newSVpv($_[0], 0)" },
+     PVN => sub { "newSVpvn($_[0], $_[1])" },
+     YES => sub { '&PL_sv_yes' },
+     NO => sub { '&PL_sv_no' },
+     UNDEF => sub { '&PL_sv_undef' },
+     '' => sub { '&PL_sv_yes' },
+     SV => sub {"SvREFCNT_inc($_[0])"},
+     );
+
+%type_to_C_value = 
+    (
+     YES => sub {},
+     NO => sub {},
+     UNDEF => sub {},
+     '' => sub {},
+     );
+
+sub type_to_C_value {
+    my ($self, $type) = @_;
+    return $type_to_C_value{$type} || sub {return map {ref $_ ? @$_ : $_} @_};
+}
+
+# TODO - figure out if there is a clean way for the type_to_sv code to
+# attempt s/sv_2mortal// and if it succeeds tell type_to_sv not to add
+# SvREFCNT_inc
+%type_is_a_problem =
+    (
+     # The documentation says *mortal SV*, but we now need a non-mortal copy.
+     SV => 1,
+     );
+
+%type_temporary =
+    (
+     SV => ['SV *'],
+     PV => ['const char *'],
+     PVN => ['const char *', 'STRLEN'],
+     );
+$type_temporary{$_} = [$_] foreach qw(IV UV NV);
+     
+while (my ($type, $value) = each %XS_TypeSet) {
+    $type_num_args{$type}
+	= defined $value ? ref $value ? scalar @$value : 1 : 0;
+}
+$type_num_args{''} = 0;
+
+sub partition_names {
+    my ($self, $default_type, @items) = @_;
+    my (%found, @notfound, @trouble);
+
+    while (my $item = shift @items) {
+	my $default = delete $item->{default};
+	if ($default) {
+	    # If we find a default value, convert it into a regular item and
+	    # append it to the queue of items to process
+	    my $default_item = {%$item};
+	    $default_item->{invert_macro} = 1;
+	    $default_item->{pre} = delete $item->{def_pre};
+	    $default_item->{post} = delete $item->{def_post};
+	    $default_item->{type} = shift @$default;
+	    $default_item->{value} = $default;
+	    push @items, $default_item;
+	} else {
+	    # It can be "not found" unless it's the default (invert the macro)
+	    # or the "macro" is an empty string (ie no macro)
+	    push @notfound, $item unless $item->{invert_macro}
+		or !$self->macro_to_ifdef($self->macro_from_item($item));
+	}
+
+	if ($item->{pre} or $item->{post} or $item->{not_constant}
+	    or $type_is_a_problem{$item->{type}}) {
+	    push @trouble, $item;
+	} else {
+	    push @{$found{$item->{type}}}, $item;
+	}
+    }
+    # use Data::Dumper; print Dumper \%found;
+    (\%found, \@notfound, \@trouble);
+}
+
+sub boottime_iterator {
+    my ($self, $type, $iterator, $hash, $subname, $push) = @_;
+    my $extractor = $type_from_struct{$type};
+    die "Can't find extractor code for type $type"
+	unless defined $extractor;
+    my $generator = $type_to_sv{$type};
+    die "Can't find generator code for type $type"
+	unless defined $generator;
+
+    my $athx = $self->C_constant_prefix_param();
+
+    if ($push) {
+	return sprintf <<"EOBOOT", &$generator(&$extractor($iterator));
+        while ($iterator->name) {
+	    he = $subname($athx $hash, $iterator->name,
+				     $iterator->namelen, %s);
+	    av_push(push, newSVhek(HeKEY_hek(he)));
+            ++$iterator;
+	}
+EOBOOT
+    } else {
+	return sprintf <<"EOBOOT", &$generator(&$extractor($iterator));
+        while ($iterator->name) {
+	    $subname($athx $hash, $iterator->name,
+				$iterator->namelen, %s);
+            ++$iterator;
+	}
+EOBOOT
+    }
+}
+
+sub name_len_value_macro {
+    my ($self, $item) = @_;
+    my $name = $item->{name};
+    my $value = $item->{value};
+    $value = $item->{name} unless defined $value;
+
+    my $namelen = length $name;
+    if ($name =~ tr/\0-\377// != $namelen) {
+	# the hash API signals UTF-8 by passing the length negated.
+	utf8::encode($name);
+	$namelen = -length $name;
+    }
+    $name = C_stringify($name);
+
+    my $macro = $self->macro_from_item($item);
+    ($name, $namelen, $value, $macro);
+}
+
+sub WriteConstants {
+    my $self = shift;
+    my $ARGS = {@_};
+
+    my ($c_fh, $xs_fh, $c_subname, $default_type, $package)
+	= @{$ARGS}{qw(C_FH XS_FH C_SUBNAME DEFAULT_TYPE NAME)};
+
+    my $xs_subname
+	= exists $ARGS->{XS_SUBNAME} ? $ARGS->{XS_SUBNAME} : 'constant';
+
+    my $options = $ARGS->{PROXYSUBS};
+    $options = {} unless ref $options;
+    my $push = $options->{push};
+    my $explosives = $options->{croak_on_read};
+    my $croak_on_error = $options->{croak_on_error};
+    my $autoload = $options->{autoload};
+    {
+	my $exclusive = 0;
+	++$exclusive if $explosives;
+	++$exclusive if $croak_on_error;
+	++$exclusive if $autoload;
+
+	# Until someone patches this (with test cases):
+	carp ("PROXYSUBS options 'autoload', 'croak_on_read' and 'croak_on_error' cannot be used together")
+	    if $exclusive > 1;
+    }
+    # Strictly it requires Perl_caller_cx
+    carp ("PROXYSUBS option 'croak_on_error' requires v5.13.5 or later")
+	if $croak_on_error && $^V < v5.13.5;
+    # Strictly this is actually 5.8.9, but it's not well tested there
+    my $can_do_pcs = $] >= 5.009;
+    # Until someone patches this (with test cases)
+    carp ("PROXYSUBS option 'push' requires v5.10 or later")
+	if $push && !$can_do_pcs;
+    # Until someone patches this (with test cases)
+    carp ("PROXYSUBS options 'push' and 'croak_on_read' cannot be used together")
+	if $explosives && $push;
+
+    # If anyone is insane enough to suggest a package name containing %
+    my $package_sprintf_safe = $package;
+    $package_sprintf_safe =~ s/%/%%/g;
+
+    # All the types we see
+    my $what = {};
+    # A hash to lookup items with.
+    my $items = {};
+
+    my @items = $self->normalise_items ({disable_utf8_duplication => 1},
+					$default_type, $what, $items,
+					@{$ARGS->{NAMES}});
+
+    # Partition the values by type. Also include any defaults in here
+    # Everything that doesn't have a default needs alternative code for
+    # "I'm missing"
+    # And everything that has pre or post code ends up in a private block
+    my ($found, $notfound, $trouble)
+	= $self->partition_names($default_type, @items);
+
+    my $pthx = $self->C_constant_prefix_param_defintion();
+    my $athx = $self->C_constant_prefix_param();
+    my $symbol_table = C_stringify($package) . '::';
+    $push = C_stringify($package . '::' . $push) if $push;
+    my $cast_CONSTSUB = $] < 5.010 ? '(char *)' : '';
+
+    print $c_fh $self->header();
+    if ($autoload || $croak_on_error) {
+	print $c_fh <<'EOC';
+
+/* This allows slightly more efficient code on !USE_ITHREADS: */
+#ifdef USE_ITHREADS
+#  define COP_FILE(c)	CopFILE(c)
+#  define COP_FILE_F	"s"
+#else
+#  define COP_FILE(c)	CopFILESV(c)
+#  define COP_FILE_F	SVf
+#endif
+EOC
+    }
+
+    my $return_type = $push ? 'HE *' : 'void';
+
+    print $c_fh <<"EOADD";
+
+static $return_type
+${c_subname}_add_symbol($pthx HV *hash, const char *name, I32 namelen, SV *value) {
+EOADD
+    if (!$can_do_pcs) {
+	print $c_fh <<'EO_NOPCS';
+    if (namelen == namelen) {
+EO_NOPCS
+    } else {
+	print $c_fh <<"EO_PCS";
+    HE *he = (HE*) hv_common_key_len(hash, name, namelen, HV_FETCH_LVALUE, NULL,
+				     0);
+    SV *sv;
+
+    if (!he) {
+        croak("Couldn't add key '%s' to %%$package_sprintf_safe\::",
+		   name);
+    }
+    sv = HeVAL(he);
+    if (SvOK(sv) || SvTYPE(sv) == SVt_PVGV) {
+	/* Someone has been here before us - have to make a real sub.  */
+EO_PCS
+    }
+    # This piece of code is common to both
+    print $c_fh <<"EOADD";
+	newCONSTSUB(hash, ${cast_CONSTSUB}name, value);
+EOADD
+    if ($can_do_pcs) {
+	print $c_fh <<'EO_PCS';
+    } else {
+	SvUPGRADE(sv, SVt_RV);
+	SvRV_set(sv, value);
+	SvROK_on(sv);
+	SvREADONLY_on(value);
+    }
+EO_PCS
+    } else {
+	print $c_fh <<'EO_NOPCS';
+    }
+EO_NOPCS
+    }
+    print $c_fh "    return he;\n" if $push;
+    print $c_fh <<'EOADD';
+}
+
+EOADD
+
+    print $c_fh $explosives ? <<"EXPLODE" : "\n";
+
+static int
+Im_sorry_Dave(pTHX_ SV *sv, MAGIC *mg)
+{
+    PERL_UNUSED_ARG(mg);
+    croak("Your vendor has not defined $package_sprintf_safe macro %"SVf
+	  " used", sv);
+    NORETURN_FUNCTION_END;
+}
+
+static MGVTBL not_defined_vtbl = {
+ Im_sorry_Dave, /* get - I'm afraid I can't do that */
+ Im_sorry_Dave, /* set */
+ 0, /* len */
+ 0, /* clear */
+ 0, /* free */
+ 0, /* copy */
+ 0, /* dup */
+};
+
+EXPLODE
+
+{
+    my $key = $symbol_table;
+    # Just seems tidier (and slightly more space efficient) not to have keys
+    # such as Fcntl::
+    $key =~ s/::$//;
+    my $key_len = length $key;
+
+    print $c_fh <<"MISSING";
+
+#ifndef SYMBIAN
+
+/* Store a hash of all symbols missing from the package. To avoid trampling on
+   the package namespace (uninvited) put each package's hash in our namespace.
+   To avoid creating lots of typeblogs and symbol tables for sub-packages, put
+   each package's hash into one hash in our namespace.  */
+
+static HV *
+get_missing_hash(pTHX) {
+    HV *const parent
+	= get_hv("ExtUtils::Constant::ProxySubs::Missing", GVf_MULTI);
+    /* We could make a hash of hashes directly, but this would confuse anything
+	at Perl space that looks at us, and as we're visible in Perl space,
+	best to play nice. */
+    SV *const *const ref
+	= hv_fetch(parent, "$key", $key_len, TRUE);
+    HV *new_hv;
+
+    if (!ref)
+	return NULL;
+
+    if (SvROK(*ref))
+	return (HV*) SvRV(*ref);
+
+    new_hv = newHV();
+    SvUPGRADE(*ref, SVt_RV);
+    SvRV_set(*ref, (SV *)new_hv);
+    SvROK_on(*ref);
+    return new_hv;
+}
+
+#endif
+
+MISSING
+
+}
+
+    print $xs_fh <<"EOBOOT";
+BOOT:
+  {
+#if defined(dTHX) && !defined(PERL_NO_GET_CONTEXT)
+    dTHX;
+#endif
+    HV *symbol_table = get_hv("$symbol_table", GV_ADD);
+EOBOOT
+    if ($push) {
+	print $xs_fh <<"EOC";
+    AV *push = get_av(\"$push\", GV_ADD);
+    HE *he;
+EOC
+    }
+
+    my %iterator;
+
+    $found->{''}
+        = [map {{%$_, type=>'', invert_macro => 1}} @$notfound];
+
+    foreach my $type (sort keys %$found) {
+	my $struct = $type_to_struct{$type};
+	my $type_to_value = $self->type_to_C_value($type);
+	my $number_of_args = $type_num_args{$type};
+	die "Can't find structure definition for type $type"
+	    unless defined $struct;
+
+	my $lc_type = $type ? lc($type) : 'notfound';
+	my $struct_type = $lc_type . '_s';
+	my $array_name = 'values_for_' . $lc_type;
+	$iterator{$type} = 'value_for_' . $lc_type;
+	# Give the notfound struct file scope. The others are scoped within the
+	# BOOT block
+	my $struct_fh = $type ? $xs_fh : $c_fh;
+
+	print $c_fh "struct $struct_type $struct;\n";
+
+	print $struct_fh <<"EOBOOT";
+
+    static const struct $struct_type $array_name\[] =
+      {
+EOBOOT
+
+
+	foreach my $item (@{$found->{$type}}) {
+            my ($name, $namelen, $value, $macro)
+                 = $self->name_len_value_macro($item);
+
+	    my $ifdef = $self->macro_to_ifdef($macro);
+	    if (!$ifdef && $item->{invert_macro}) {
+		carp("Attempting to supply a default for '$name' which has no conditional macro");
+		next;
+	    }
+	    if ($item->{invert_macro}) {
+		print $struct_fh $self->macro_to_ifndef($macro);
+		print $struct_fh
+			"        /* This is the default value: */\n" if $type;
+	    } else {
+		print $struct_fh $ifdef;
+	    }
+	    print $struct_fh "        { ", join (', ', "\"$name\"", $namelen,
+						 &$type_to_value($value)),
+						 " },\n",
+						 $self->macro_to_endif($macro);
+	}
+
+    # Terminate the list with a NULL
+	print $struct_fh "        { NULL, 0", (", 0" x $number_of_args), " } };\n";
+
+	print $xs_fh <<"EOBOOT" if $type;
+	const struct $struct_type *$iterator{$type} = $array_name;
+EOBOOT
+    }
+
+    delete $found->{''};
+
+    my $add_symbol_subname = $c_subname . '_add_symbol';
+    foreach my $type (sort keys %$found) {
+	print $xs_fh $self->boottime_iterator($type, $iterator{$type}, 
+					      'symbol_table',
+					      $add_symbol_subname, $push);
+    }
+
+    print $xs_fh <<"EOBOOT";
+	if (C_ARRAY_LENGTH(values_for_notfound) > 1) {
+#ifndef SYMBIAN
+	    HV *const ${c_subname}_missing = get_missing_hash(aTHX);
+#endif
+	    const struct notfound_s *value_for_notfound = values_for_notfound;
+	    do {
+EOBOOT
+
+    print $xs_fh $explosives ? <<"EXPLODE" : << "DONT";
+		SV *tripwire = newSV(0);
+		
+		sv_magicext(tripwire, 0, PERL_MAGIC_ext, &not_defined_vtbl, 0, 0);
+		SvPV_set(tripwire, (char *)value_for_notfound->name);
+		if(value_for_notfound->namelen >= 0) {
+		    SvCUR_set(tripwire, value_for_notfound->namelen);
+	    	} else {
+		    SvCUR_set(tripwire, -value_for_notfound->namelen);
+		    SvUTF8_on(tripwire);
+		}
+		SvPOKp_on(tripwire);
+		SvREADONLY_on(tripwire);
+		assert(SvLEN(tripwire) == 0);
+
+		$add_symbol_subname($athx symbol_table, value_for_notfound->name,
+				    value_for_notfound->namelen, tripwire);
+EXPLODE
+
+		/* Need to add prototypes, else parsing will vary by platform.  */
+		HE *he = (HE*) hv_common_key_len(symbol_table,
+						 value_for_notfound->name,
+						 value_for_notfound->namelen,
+						 HV_FETCH_LVALUE, NULL, 0);
+		SV *sv;
+#ifndef SYMBIAN
+		HEK *hek;
+#endif
+		if (!he) {
+		    croak("Couldn't add key '%s' to %%$package_sprintf_safe\::",
+			  value_for_notfound->name);
+		}
+		sv = HeVAL(he);
+		if (!SvOK(sv) && SvTYPE(sv) != SVt_PVGV) {
+		    /* Nothing was here before, so mark a prototype of ""  */
+		    sv_setpvn(sv, "", 0);
+		} else if (SvPOK(sv) && SvCUR(sv) == 0) {
+		    /* There is already a prototype of "" - do nothing  */
+		} else {
+		    /* Someone has been here before us - have to make a real
+		       typeglob.  */
+		    /* It turns out to be incredibly hard to deal with all the
+		       corner cases of sub foo (); and reporting errors correctly,
+		       so lets cheat a bit.  Start with a constant subroutine  */
+		    CV *cv = newCONSTSUB(symbol_table,
+					 ${cast_CONSTSUB}value_for_notfound->name,
+					 &PL_sv_yes);
+		    /* and then turn it into a non constant declaration only.  */
+		    SvREFCNT_dec(CvXSUBANY(cv).any_ptr);
+		    CvCONST_off(cv);
+		    CvXSUB(cv) = NULL;
+		    CvXSUBANY(cv).any_ptr = NULL;
+		}
+#ifndef SYMBIAN
+		hek = HeKEY_hek(he);
+		if (!hv_common(${c_subname}_missing, NULL, HEK_KEY(hek),
+ 			       HEK_LEN(hek), HEK_FLAGS(hek), HV_FETCH_ISSTORE,
+			       &PL_sv_yes, HEK_HASH(hek)))
+		    croak("Couldn't add key '%s' to missing_hash",
+			  value_for_notfound->name);
+#endif
+DONT
+
+    print $xs_fh "		av_push(push, newSVhek(hek));\n"
+	if $push;
+
+    print $xs_fh <<"EOBOOT";
+	    } while ((++value_for_notfound)->name);
+	}
+EOBOOT
+
+    foreach my $item (@$trouble) {
+        my ($name, $namelen, $value, $macro)
+	    = $self->name_len_value_macro($item);
+        my $ifdef = $self->macro_to_ifdef($macro);
+        my $type = $item->{type};
+	my $type_to_value = $self->type_to_C_value($type);
+
+        print $xs_fh $ifdef;
+	if ($item->{invert_macro}) {
+	    print $xs_fh
+		 "        /* This is the default value: */\n" if $type;
+	    print $xs_fh "#else\n";
+	}
+	my $generator = $type_to_sv{$type};
+	die "Can't find generator code for type $type"
+	    unless defined $generator;
+
+	print $xs_fh "        {\n";
+	# We need to use a temporary value because some really troublesome
+	# items use C pre processor directives in their values, and in turn
+	# these don't fit nicely in the macro-ised generator functions
+	my $counter = 0;
+	printf $xs_fh "            %s temp%d;\n", $_, $counter++
+	    foreach @{$type_temporary{$type}};
+
+	print $xs_fh "            $item->{pre}\n" if $item->{pre};
+
+	# And because the code in pre might be both declarations and
+	# statements, we can't declare and assign to the temporaries in one.
+	$counter = 0;
+	printf $xs_fh "            temp%d = %s;\n", $counter++, $_
+	    foreach &$type_to_value($value);
+
+	my @tempvarnames = map {sprintf 'temp%d', $_} 0 .. $counter - 1;
+	printf $xs_fh <<"EOBOOT", $name, &$generator(@tempvarnames);
+	    ${c_subname}_add_symbol($athx symbol_table, "%s",
+				    $namelen, %s);
+EOBOOT
+	print $xs_fh "        $item->{post}\n" if $item->{post};
+	print $xs_fh "        }\n";
+
+        print $xs_fh $self->macro_to_endif($macro);
+    }
+
+    if ($] >= 5.009) {
+	print $xs_fh <<EOBOOT;
+    /* As we've been creating subroutines, we better invalidate any cached
+       methods  */
+    mro_method_changed_in(symbol_table);
+  }
+EOBOOT
+    } else {
+	print $xs_fh <<EOBOOT;
+    /* As we've been creating subroutines, we better invalidate any cached
+       methods  */
+    ++PL_sub_generation;
+  }
+EOBOOT
+    }
+
+    return if !defined $xs_subname;
+
+    if ($croak_on_error || $autoload) {
+        print $xs_fh $croak_on_error ? <<"EOC" : <<'EOA';
+
+void
+$xs_subname(sv)
+    INPUT:
+	SV *		sv;
+    PREINIT:
+	const PERL_CONTEXT *cx = caller_cx(0, NULL);
+	/* cx is NULL if we've been called from the top level. PL_curcop isn't
+	   ideal, but it's much cheaper than other ways of not going SEGV.  */
+	const COP *cop = cx ? cx->blk_oldcop : PL_curcop;
+EOC
+
+void
+AUTOLOAD()
+    PROTOTYPE: DISABLE
+    PREINIT:
+	SV *sv = newSVpvn_flags(SvPVX(cv), SvCUR(cv), SVs_TEMP | SvUTF8(cv));
+	const COP *cop = PL_curcop;
+EOA
+        print $xs_fh <<"EOC";
+    PPCODE:
+#ifndef SYMBIAN
+	/* It's not obvious how to calculate this at C pre-processor time.
+	   However, any compiler optimiser worth its salt should be able to
+	   remove the dead code, and hopefully the now-obviously-unused static
+	   function too.  */
+	HV *${c_subname}_missing = (C_ARRAY_LENGTH(values_for_notfound) > 1)
+	    ? get_missing_hash(aTHX) : NULL;
+	if ((C_ARRAY_LENGTH(values_for_notfound) > 1)
+	    ? hv_exists_ent(${c_subname}_missing, sv, 0) : 0) {
+	    sv = newSVpvf("Your vendor has not defined $package_sprintf_safe macro %" SVf
+			  ", used at %" COP_FILE_F " line %" UVuf "\\n", 
+			  sv, COP_FILE(cop), (UV)CopLINE(cop));
+	} else
+#endif
+	{
+	    sv = newSVpvf("%" SVf
+                          " is not a valid $package_sprintf_safe macro at %"
+			  COP_FILE_F " line %" UVuf "\\n",
+			  sv, COP_FILE(cop), (UV)CopLINE(cop));
+	}
+	croak_sv(sv_2mortal(sv));
+EOC
+    } else {
+        print $xs_fh $explosives ? <<"EXPLODE" : <<"DONT";
+
+void
+$xs_subname(sv)
+    INPUT:
+	SV *		sv;
+    PPCODE:
+	sv = newSVpvf("Your vendor has not defined $package_sprintf_safe macro %" SVf
+			  ", used", sv);
+        PUSHs(sv_2mortal(sv));
+EXPLODE
+
+void
+$xs_subname(sv)
+    INPUT:
+	SV *		sv;
+    PPCODE:
+#ifndef SYMBIAN
+	/* It's not obvious how to calculate this at C pre-processor time.
+	   However, any compiler optimiser worth its salt should be able to
+	   remove the dead code, and hopefully the now-obviously-unused static
+	   function too.  */
+	HV *${c_subname}_missing = (C_ARRAY_LENGTH(values_for_notfound) > 1)
+	    ? get_missing_hash(aTHX) : NULL;
+	if ((C_ARRAY_LENGTH(values_for_notfound) > 1)
+	    ? hv_exists_ent(${c_subname}_missing, sv, 0) : 0) {
+	    sv = newSVpvf("Your vendor has not defined $package_sprintf_safe macro %" SVf
+			  ", used", sv);
+	} else
+#endif
+	{
+	    sv = newSVpvf("%" SVf " is not a valid $package_sprintf_safe macro",
+			  sv);
+	}
+	PUSHs(sv_2mortal(sv));
+DONT
+    }
+}
+
+1;

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/Constant/XS.pm

@@ -0,0 +1,259 @@
+package ExtUtils::Constant::XS;
+
+use strict;
+use vars qw($VERSION %XS_Constant %XS_TypeSet @ISA @EXPORT_OK $is_perl56);
+use Carp;
+use ExtUtils::Constant::Utils 'perl_stringify';
+require ExtUtils::Constant::Base;
+
+
+@ISA = qw(ExtUtils::Constant::Base Exporter);
+@EXPORT_OK = qw(%XS_Constant %XS_TypeSet);
+
+$VERSION = '0.03';
+
+$is_perl56 = ($] < 5.007 && $] > 5.005_50);
+
+=head1 NAME
+
+ExtUtils::Constant::XS - generate C code for XS modules' constants.
+
+=head1 SYNOPSIS
+
+    require ExtUtils::Constant::XS;
+
+=head1 DESCRIPTION
+
+ExtUtils::Constant::XS overrides ExtUtils::Constant::Base to generate C
+code for XS modules' constants.
+
+=head1 BUGS
+
+Nothing is documented.
+
+Probably others.
+
+=head1 AUTHOR
+
+Nicholas Clark <[email protected]> based on the code in C<h2xs> by Larry Wall and
+others
+
+=cut
+
+# '' is used as a flag to indicate non-ascii macro names, and hence the need
+# to pass in the utf8 on/off flag.
+%XS_Constant = (
+		''    => '',
+		IV    => 'PUSHi(iv)',
+		UV    => 'PUSHu((UV)iv)',
+		NV    => 'PUSHn(nv)',
+		PV    => 'PUSHp(pv, strlen(pv))',
+		PVN   => 'PUSHp(pv, iv)',
+		SV    => 'PUSHs(sv)',
+		YES   => 'PUSHs(&PL_sv_yes)',
+		NO    => 'PUSHs(&PL_sv_no)',
+		UNDEF => '',	# implicit undef
+);
+
+%XS_TypeSet = (
+		IV    => '*iv_return = ',
+		UV    => '*iv_return = (IV)',
+		NV    => '*nv_return = ',
+		PV    => '*pv_return = ',
+		PVN   => ['*pv_return = ', '*iv_return = (IV)'],
+		SV    => '*sv_return = ',
+		YES   => undef,
+		NO    => undef,
+		UNDEF => undef,
+);
+
+sub header {
+  my $start = 1;
+  my @lines;
+  push @lines, "#define PERL_constant_NOTFOUND\t$start\n"; $start++;
+  push @lines, "#define PERL_constant_NOTDEF\t$start\n"; $start++;
+  foreach (sort keys %XS_Constant) {
+    next if $_ eq '';
+    push @lines, "#define PERL_constant_IS$_\t$start\n"; $start++;
+  }
+  push @lines, << 'EOT';
+
+#ifndef NVTYPE
+typedef double NV; /* 5.6 and later define NVTYPE, and typedef NV to it.  */
+#endif
+#ifndef aTHX_
+#define aTHX_ /* 5.6 or later define this for threading support.  */
+#endif
+#ifndef pTHX_
+#define pTHX_ /* 5.6 or later define this for threading support.  */
+#endif
+EOT
+
+  return join '', @lines;
+}
+
+sub valid_type {
+  my ($self, $type) = @_;
+  return exists $XS_TypeSet{$type};
+}
+
+# This might actually be a return statement
+sub assignment_clause_for_type {
+  my $self = shift;
+  my $args = shift;
+  my $type = $args->{type};
+  my $typeset = $XS_TypeSet{$type};
+  if (ref $typeset) {
+    die "Type $type is aggregate, but only single value given"
+      if @_ == 1;
+    return map {"$typeset->[$_]$_[$_];"} 0 .. $#$typeset;
+  } elsif (defined $typeset) {
+    confess "Aggregate value given for type $type"
+      if @_ > 1;
+    return "$typeset$_[0];";
+  }
+  return ();
+}
+
+sub return_statement_for_type {
+  my ($self, $type) = @_;
+  # In the future may pass in an options hash
+  $type = $type->{type} if ref $type;
+  "return PERL_constant_IS$type;";
+}
+
+sub return_statement_for_notdef {
+  # my ($self) = @_;
+  "return PERL_constant_NOTDEF;";
+}
+
+sub return_statement_for_notfound {
+  # my ($self) = @_;
+  "return PERL_constant_NOTFOUND;";
+}
+
+sub default_type {
+  'IV';
+}
+
+sub macro_from_name {
+  my ($self, $item) = @_;
+  my $macro = $item->{name};
+  $macro = $item->{value} unless defined $macro;
+  $macro;
+}
+
+sub macro_from_item {
+  my ($self, $item) = @_;
+  my $macro = $item->{macro};
+  $macro = $self->macro_from_name($item) unless defined $macro;
+  $macro;
+}
+
+# Keep to the traditional perl source macro
+sub memEQ {
+  "memEQ";
+}
+
+sub params {
+  my ($self, $what) = @_;
+  foreach (sort keys %$what) {
+    warn "ExtUtils::Constant doesn't know how to handle values of type $_" unless defined $XS_Constant{$_};
+  }
+  my $params = {};
+  $params->{''} = 1 if $what->{''};
+  $params->{IV} = 1 if $what->{IV} || $what->{UV} || $what->{PVN};
+  $params->{NV} = 1 if $what->{NV};
+  $params->{PV} = 1 if $what->{PV} || $what->{PVN};
+  $params->{SV} = 1 if $what->{SV};
+  return $params;
+}
+
+
+sub C_constant_prefix_param {
+  "aTHX_ ";
+}
+
+sub C_constant_prefix_param_defintion {
+  "pTHX_ ";
+}
+
+sub namelen_param_definition {
+  'STRLEN ' . $_[0] -> namelen_param;
+}
+
+sub C_constant_other_params_defintion {
+  my ($self, $params) = @_;
+  my $body = '';
+  $body .= ", int utf8" if $params->{''};
+  $body .= ", IV *iv_return" if $params->{IV};
+  $body .= ", NV *nv_return" if $params->{NV};
+  $body .= ", const char **pv_return" if $params->{PV};
+  $body .= ", SV **sv_return" if $params->{SV};
+  $body;
+}
+
+sub C_constant_other_params {
+  my ($self, $params) = @_;
+  my $body = '';
+  $body .= ", utf8" if $params->{''};
+  $body .= ", iv_return" if $params->{IV};
+  $body .= ", nv_return" if $params->{NV};
+  $body .= ", pv_return" if $params->{PV};
+  $body .= ", sv_return" if $params->{SV};
+  $body;
+}
+
+sub dogfood {
+  my ($self, $args, @items) = @_;
+  my ($package, $subname, $default_type, $what, $indent, $breakout) =
+    @{$args}{qw(package subname default_type what indent breakout)};
+  my $result = <<"EOT";
+  /* When generated this function returned values for the list of names given
+     in this section of perl code.  Rather than manually editing these functions
+     to add or remove constants, which would result in this comment and section
+     of code becoming inaccurate, we recommend that you edit this section of
+     code, and use it to regenerate a new set of constant functions which you
+     then use to replace the originals.
+
+     Regenerate these constant functions by feeding this entire source file to
+     perl -x
+
+#!$^X -w
+use ExtUtils::Constant qw (constant_types C_constant XS_constant);
+
+EOT
+  $result .= $self->dump_names ({default_type=>$default_type, what=>$what,
+				 indent=>0, declare_types=>1},
+				@items);
+  $result .= <<'EOT';
+
+print constant_types(), "\n"; # macro defs
+EOT
+  $package = perl_stringify($package);
+  $result .=
+    "foreach (C_constant (\"$package\", '$subname', '$default_type', \$types, ";
+  # The form of the indent parameter isn't defined. (Yet)
+  if (defined $indent) {
+    require Data::Dumper;
+    $Data::Dumper::Terse=1;
+    $Data::Dumper::Terse=1; # Not used once. :-)
+    chomp ($indent = Data::Dumper::Dumper ($indent));
+    $result .= $indent;
+  } else {
+    $result .= 'undef';
+  }
+  $result .= ", $breakout" . ', @names) ) {
+    print $_, "\n"; # C constant subs
+}
+print "\n#### XS Section:\n";
+print XS_constant ("' . $package . '", $types);
+__END__
+   */
+
+';
+
+  $result;
+}
+
+1;

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/MakeMaker/FAQ.pod

@@ -0,0 +1,666 @@
+package ExtUtils::MakeMaker::FAQ;
+
+our $VERSION = '7.34';
+$VERSION = eval $VERSION;
+
+1;
+__END__
+
+=head1 NAME
+
+ExtUtils::MakeMaker::FAQ - Frequently Asked Questions About MakeMaker
+
+=head1 DESCRIPTION
+
+FAQs, tricks and tips for C<ExtUtils::MakeMaker>.
+
+
+=head2 Module Installation
+
+=over 4
+
+=item How do I install a module into my home directory?
+
+If you're not the Perl administrator you probably don't have
+permission to install a module to its default location. Ways of handling
+this with a B<lot> less manual effort on your part are L<perlbrew>
+and L<local::lib>.
+
+Otherwise, you can install it for your own use into your home directory
+like so:
+
+    # Non-unix folks, replace ~ with /path/to/your/home/dir
+    perl Makefile.PL INSTALL_BASE=~
+
+This will put modules into F<~/lib/perl5>, man pages into F<~/man> and
+programs into F<~/bin>.
+
+To ensure your Perl programs can see these newly installed modules,
+set your C<PERL5LIB> environment variable to F<~/lib/perl5> or tell
+each of your programs to look in that directory with the following:
+
+    use lib "$ENV{HOME}/lib/perl5";
+
+or if $ENV{HOME} isn't set and you don't want to set it for some
+reason, do it the long way.
+
+    use lib "/path/to/your/home/dir/lib/perl5";
+
+=item How do I get MakeMaker and Module::Build to install to the same place?
+
+Module::Build, as of 0.28, supports two ways to install to the same
+location as MakeMaker.
+
+We highly recommend the install_base method, its the simplest and most
+closely approximates the expected behavior of an installation prefix.
+
+1) Use INSTALL_BASE / C<--install_base>
+
+MakeMaker (as of 6.31) and Module::Build (as of 0.28) both can install
+to the same locations using the "install_base" concept.  See
+L<ExtUtils::MakeMaker/INSTALL_BASE> for details.  To get MM and MB to
+install to the same location simply set INSTALL_BASE in MM and
+C<--install_base> in MB to the same location.
+
+    perl Makefile.PL INSTALL_BASE=/whatever
+    perl Build.PL    --install_base /whatever
+
+This works most like other language's behavior when you specify a
+prefix.  We recommend this method.
+
+2) Use PREFIX / C<--prefix>
+
+Module::Build 0.28 added support for C<--prefix> which works like
+MakeMaker's PREFIX.
+
+    perl Makefile.PL PREFIX=/whatever
+    perl Build.PL    --prefix /whatever
+
+We highly discourage this method.  It should only be used if you know
+what you're doing and specifically need the PREFIX behavior.  The
+PREFIX algorithm is complicated and focused on matching the system
+installation.
+
+=item How do I keep from installing man pages?
+
+Recent versions of MakeMaker will only install man pages on Unix-like
+operating systems.
+
+For an individual module:
+
+        perl Makefile.PL INSTALLMAN1DIR=none INSTALLMAN3DIR=none
+
+If you want to suppress man page installation for all modules you have
+to reconfigure Perl and tell it 'none' when it asks where to install
+man pages.
+
+
+=item How do I use a module without installing it?
+
+Two ways.  One is to build the module normally...
+
+        perl Makefile.PL
+        make
+        make test
+
+...and then use L<blib> to point Perl at the built but uninstalled module:
+
+	perl -Mblib script.pl
+	perl -Mblib -e '...'
+
+The other is to install the module in a temporary location.
+
+        perl Makefile.PL INSTALL_BASE=~/tmp
+        make
+        make test
+        make install
+
+And then set PERL5LIB to F<~/tmp/lib/perl5>.  This works well when you
+have multiple modules to work with.  It also ensures that the module
+goes through its full installation process which may modify it.
+Again, L<local::lib> may assist you here.
+
+=item How can I organize tests into subdirectories and have them run?
+
+Let's take the following test directory structure:
+
+    t/foo/sometest.t
+    t/bar/othertest.t
+    t/bar/baz/anothertest.t
+
+Now, inside of the C<WriteMakeFile()> function in your F<Makefile.PL>, specify
+where your tests are located with the C<test> directive:
+
+    test => {TESTS => 't/*.t t/*/*.t t/*/*/*.t'}
+
+The first entry in the string will run all tests in the top-level F<t/> 
+directory. The second will run all test files located in any subdirectory under
+F<t/>. The third, runs all test files within any subdirectory within any other
+subdirectory located under F<t/>.
+
+Note that you do not have to use wildcards. You can specify explicitly which
+subdirectories to run tests in:
+
+    test => {TESTS => 't/*.t t/foo/*.t t/bar/baz/*.t'}
+
+=item PREFIX vs INSTALL_BASE from Module::Build::Cookbook
+
+The behavior of PREFIX is complicated and depends closely on how your
+Perl is configured. The resulting installation locations will vary
+from machine to machine and even different installations of Perl on the
+same machine.  Because of this, its difficult to document where prefix
+will place your modules.
+
+In contrast, INSTALL_BASE has predictable, easy to explain installation
+locations.  Now that Module::Build and MakeMaker both have INSTALL_BASE
+there is little reason to use PREFIX other than to preserve your existing
+installation locations. If you are starting a fresh Perl installation we
+encourage you to use INSTALL_BASE. If you have an existing installation
+installed via PREFIX, consider moving it to an installation structure
+matching INSTALL_BASE and using that instead.
+
+=item Generating *.pm files with substitutions eg of $VERSION
+
+If you want to configure your module files for local conditions, or to
+automatically insert a version number, you can use EUMM's C<PL_FILES>
+capability, where it will automatically run each F<*.PL> it finds to
+generate its basename. For instance:
+
+    # Makefile.PL:
+    require 'common.pl';
+    my $version = get_version();
+    my @pms = qw(Foo.pm);
+    WriteMakefile(
+      NAME => 'Foo',
+      VERSION => $version,
+      PM => { map { ($_ => "\$(INST_LIB)/$_") } @pms },
+      clean => { FILES => join ' ', @pms },
+    );
+
+    # common.pl:
+    sub get_version { '0.04' }
+    sub process { my $v = get_version(); s/__VERSION__/$v/g; }
+    1;
+
+    # Foo.pm.PL:
+    require 'common.pl';
+    $_ = join '', <DATA>;
+    process();
+    my $file = shift;
+    open my $fh, '>', $file or die "$file: $!";
+    print $fh $_;
+    __DATA__
+    package Foo;
+    our $VERSION = '__VERSION__';
+    1;
+
+You may notice that C<PL_FILES> is not specified above, since the default
+of mapping each .PL file to its basename works well.
+
+If the generated module were architecture-specific, you could replace
+C<$(INST_LIB)> above with C<$(INST_ARCHLIB)>, although if you locate
+modules under F<lib>, that would involve ensuring any C<lib/> in front
+of the module location were removed.
+
+=back
+
+=head2 Common errors and problems
+
+=over 4
+
+=item "No rule to make target `/usr/lib/perl5/CORE/config.h', needed by `Makefile'"
+
+Just what it says, you're missing that file.  MakeMaker uses it to
+determine if perl has been rebuilt since the Makefile was made.  It's
+a bit of a bug that it halts installation.
+
+Some operating systems don't ship the CORE directory with their base
+perl install.  To solve the problem, you likely need to install a perl
+development package such as perl-devel (CentOS, Fedora and other
+Redhat systems) or perl (Ubuntu and other Debian systems).
+
+=back
+
+=head2 Philosophy and History
+
+=over 4
+
+=item Why not just use <insert other build config tool here>?
+
+Why did MakeMaker reinvent the build configuration wheel?  Why not
+just use autoconf or automake or ppm or Ant or ...
+
+There are many reasons, but the major one is cross-platform
+compatibility.
+
+Perl is one of the most ported pieces of software ever.  It works on
+operating systems I've never even heard of (see perlport for details).
+It needs a build tool that can work on all those platforms and with
+any wacky C compilers and linkers they might have.
+
+No such build tool exists.  Even make itself has wildly different
+dialects.  So we have to build our own.
+
+
+=item What is Module::Build and how does it relate to MakeMaker?
+
+Module::Build is a project by Ken Williams to supplant MakeMaker.
+Its primary advantages are:
+
+=over 8
+
+=item * pure perl.  no make, no shell commands
+
+=item * easier to customize
+
+=item * cleaner internals
+
+=item * less cruft
+
+=back
+
+Module::Build was long the official heir apparent to MakeMaker.  The
+rate of both its development and adoption has slowed in recent years,
+though, and it is unclear what the future holds for it.  That said,
+Module::Build set the stage for I<something> to become the heir to
+MakeMaker.  MakeMaker's maintainers have long said that it is a dead
+end and should be kept functioning, while being cautious about extending
+with new features.
+
+=back
+
+=head2 Module Writing
+
+=over 4
+
+=item How do I keep my $VERSION up to date without resetting it manually?
+
+Often you want to manually set the $VERSION in the main module
+distribution because this is the version that everybody sees on CPAN
+and maybe you want to customize it a bit.  But for all the other
+modules in your dist, $VERSION is really just bookkeeping and all that's
+important is it goes up every time the module is changed.  Doing this
+by hand is a pain and you often forget.
+
+Probably the easiest way to do this is using F<perl-reversion> in
+L<Perl::Version>:
+
+  perl-reversion -bump
+
+If your version control system supports revision numbers (git doesn't
+easily), the simplest way to do it automatically is to use its revision
+number (you are using version control, right?).
+
+In CVS, RCS and SVN you use $Revision$ (see the documentation of your
+version control system for details).  Every time the file is checked
+in the $Revision$ will be updated, updating your $VERSION.
+
+SVN uses a simple integer for $Revision$ so you can adapt it for your
+$VERSION like so:
+
+    ($VERSION) = q$Revision$ =~ /(\d+)/;
+
+In CVS and RCS version 1.9 is followed by 1.10.  Since CPAN compares
+version numbers numerically we use a sprintf() to convert 1.9 to 1.009
+and 1.10 to 1.010 which compare properly.
+
+    $VERSION = sprintf "%d.%03d", q$Revision$ =~ /(\d+)\.(\d+)/g;
+
+If branches are involved (ie. $Revision: 1.5.3.4$) it's a little more
+complicated.
+
+    # must be all on one line or MakeMaker will get confused.
+    $VERSION = do { my @r = (q$Revision$ =~ /\d+/g); sprintf "%d."."%03d" x $#r, @r };
+
+In SVN, $Revision$ should be the same for every file in the project so
+they would all have the same $VERSION.  CVS and RCS have a different
+$Revision$ per file so each file will have a different $VERSION.
+Distributed version control systems, such as SVK, may have a different
+$Revision$ based on who checks out the file, leading to a different $VERSION
+on each machine!  Finally, some distributed version control systems, such
+as darcs, have no concept of revision number at all.
+
+
+=item What's this F<META.yml> thing and how did it get in my F<MANIFEST>?!
+
+F<META.yml> is a module meta-data file pioneered by Module::Build and
+automatically generated as part of the 'distdir' target (and thus
+'dist').  See L<ExtUtils::MakeMaker/"Module Meta-Data">.
+
+To shut off its generation, pass the C<NO_META> flag to C<WriteMakefile()>.
+
+
+=item How do I delete everything not in my F<MANIFEST>?
+
+Some folks are surprised that C<make distclean> does not delete
+everything not listed in their MANIFEST (thus making a clean
+distribution) but only tells them what they need to delete.  This is
+done because it is considered too dangerous.  While developing your
+module you might write a new file, not add it to the MANIFEST, then
+run a C<distclean> and be sad because your new work was deleted.
+
+If you really want to do this, you can use
+C<ExtUtils::Manifest::manifind()> to read the MANIFEST and File::Find
+to delete the files.  But you have to be careful.  Here's a script to
+do that.  Use at your own risk.  Have fun blowing holes in your foot.
+
+    #!/usr/bin/perl -w
+
+    use strict;
+
+    use File::Spec;
+    use File::Find;
+    use ExtUtils::Manifest qw(maniread);
+
+    my %manifest = map  {( $_ => 1 )}
+                   grep { File::Spec->canonpath($_) }
+                        keys %{ maniread() };
+
+    if( !keys %manifest ) {
+        print "No files found in MANIFEST.  Stopping.\n";
+        exit;
+    }
+
+    find({
+          wanted   => sub {
+              my $path = File::Spec->canonpath($_);
+
+              return unless -f $path;
+              return if exists $manifest{ $path };
+
+              print "unlink $path\n";
+              unlink $path;
+          },
+          no_chdir => 1
+         },
+         "."
+    );
+
+
+=item Which tar should I use on Windows?
+
+We recommend ptar from Archive::Tar not older than 1.66 with '-C' option.
+
+=item Which zip should I use on Windows for '[ndg]make zipdist'?
+
+We recommend InfoZIP: L<http://www.info-zip.org/Zip.html>
+
+
+=back
+
+=head2 XS
+
+=over 4
+
+=item How do I prevent "object version X.XX does not match bootstrap parameter Y.YY" errors?
+
+XS code is very sensitive to the module version number and will
+complain if the version number in your Perl module doesn't match.  If
+you change your module's version # without rerunning Makefile.PL the old
+version number will remain in the Makefile, causing the XS code to be built
+with the wrong number.
+
+To avoid this, you can force the Makefile to be rebuilt whenever you
+change the module containing the version number by adding this to your
+WriteMakefile() arguments.
+
+    depend => { '$(FIRST_MAKEFILE)' => '$(VERSION_FROM)' }
+
+
+=item How do I make two or more XS files coexist in the same directory?
+
+Sometimes you need to have two and more XS files in the same package.
+There are three ways: C<XSMULTI>, separate directories, and bootstrapping
+one XS from another.
+
+=over 8
+
+=item XSMULTI
+
+Structure your modules so they are all located under F<lib>, such that
+C<Foo::Bar> is in F<lib/Foo/Bar.pm> and F<lib/Foo/Bar.xs>, etc. Have your
+top-level C<WriteMakefile> set the variable C<XSMULTI> to a true value.
+
+Er, that's it.
+
+=item Separate directories
+
+Put each XS files into separate directories, each with their own
+F<Makefile.PL>. Make sure each of those F<Makefile.PL>s has the correct
+C<CFLAGS>, C<INC>, C<LIBS> etc. You will need to make sure the top-level
+F<Makefile.PL> refers to each of these using C<DIR>.
+
+=item Bootstrapping
+
+Let's assume that we have a package C<Cool::Foo>, which includes
+C<Cool::Foo> and C<Cool::Bar> modules each having a separate XS
+file. First we use the following I<Makefile.PL>:
+
+  use ExtUtils::MakeMaker;
+
+  WriteMakefile(
+      NAME		=> 'Cool::Foo',
+      VERSION_FROM	=> 'Foo.pm',
+      OBJECT              => q/$(O_FILES)/,
+      # ... other attrs ...
+  );
+
+Notice the C<OBJECT> attribute. MakeMaker generates the following
+variables in I<Makefile>:
+
+  # Handy lists of source code files:
+  XS_FILES= Bar.xs \
+  	Foo.xs
+  C_FILES = Bar.c \
+  	Foo.c
+  O_FILES = Bar.o \
+  	Foo.o
+
+Therefore we can use the C<O_FILES> variable to tell MakeMaker to use
+these objects into the shared library.
+
+That's pretty much it. Now write I<Foo.pm> and I<Foo.xs>, I<Bar.pm>
+and I<Bar.xs>, where I<Foo.pm> bootstraps the shared library and
+I<Bar.pm> simply loading I<Foo.pm>.
+
+The only issue left is to how to bootstrap I<Bar.xs>. This is done
+from I<Foo.xs>:
+
+  MODULE = Cool::Foo PACKAGE = Cool::Foo
+
+  BOOT:
+  # boot the second XS file
+  boot_Cool__Bar(aTHX_ cv);
+
+If you have more than two files, this is the place where you should
+boot extra XS files from.
+
+The following four files sum up all the details discussed so far.
+
+  Foo.pm:
+  -------
+  package Cool::Foo;
+
+  require DynaLoader;
+
+  our @ISA = qw(DynaLoader);
+  our $VERSION = '0.01';
+  bootstrap Cool::Foo $VERSION;
+
+  1;
+
+  Bar.pm:
+  -------
+  package Cool::Bar;
+
+  use Cool::Foo; # bootstraps Bar.xs
+
+  1;
+
+  Foo.xs:
+  -------
+  #include "EXTERN.h"
+  #include "perl.h"
+  #include "XSUB.h"
+
+  MODULE = Cool::Foo  PACKAGE = Cool::Foo
+
+  BOOT:
+  # boot the second XS file
+  boot_Cool__Bar(aTHX_ cv);
+
+  MODULE = Cool::Foo  PACKAGE = Cool::Foo  PREFIX = cool_foo_
+
+  void
+  cool_foo_perl_rules()
+
+      CODE:
+      fprintf(stderr, "Cool::Foo says: Perl Rules\n");
+
+  Bar.xs:
+  -------
+  #include "EXTERN.h"
+  #include "perl.h"
+  #include "XSUB.h"
+
+  MODULE = Cool::Bar  PACKAGE = Cool::Bar PREFIX = cool_bar_
+
+  void
+  cool_bar_perl_rules()
+
+      CODE:
+      fprintf(stderr, "Cool::Bar says: Perl Rules\n");
+
+And of course a very basic test:
+
+  t/cool.t:
+  --------
+  use Test;
+  BEGIN { plan tests => 1 };
+  use Cool::Foo;
+  use Cool::Bar;
+  Cool::Foo::perl_rules();
+  Cool::Bar::perl_rules();
+  ok 1;
+
+This tip has been brought to you by Nick Ing-Simmons and Stas Bekman.
+
+An alternative way to achieve this can be seen in L<Gtk2::CodeGen>
+and L<Glib::CodeGen>.
+
+=back
+
+=back
+
+=head1 DESIGN
+
+=head2 MakeMaker object hierarchy (simplified)
+
+What most people need to know (superclasses on top.)
+
+        ExtUtils::MM_Any
+                |
+        ExtUtils::MM_Unix
+                |
+        ExtUtils::MM_{Current OS}
+                |
+        ExtUtils::MakeMaker
+                |
+               MY
+
+The object actually used is of the class MY which allows you to
+override bits of MakeMaker inside your Makefile.PL by declaring
+MY::foo() methods.
+
+=head2 MakeMaker object hierarchy (real)
+
+Here's how it really works:
+
+                                    ExtUtils::MM_Any
+                                            |
+                                    ExtUtils::MM_Unix
+                                            |
+    ExtUtils::Liblist::Kid          ExtUtils::MM_{Current OS} (if necessary)
+          |                                          |
+    ExtUtils::Liblist     ExtUtils::MakeMaker        |
+                    |     |                          |   
+                    |     |   |-----------------------
+                   ExtUtils::MM
+                   |          |
+        ExtUtils::MY         MM (created by ExtUtils::MM)
+        |                                   |
+        MY (created by ExtUtils::MY)        |
+                    .                       |
+                 (mixin)                    |
+                    .                       |
+               PACK### (created each call to ExtUtils::MakeMaker->new)
+
+NOTE: Yes, this is a mess.  See
+L<http://archive.develooper.com/[email protected]/msg00134.html>
+for some history.
+
+NOTE: When ExtUtils::MM is loaded it chooses a superclass for MM from
+amongst the ExtUtils::MM_* modules based on the current operating
+system.
+
+NOTE: ExtUtils::MM_{Current OS} represents one of the ExtUtils::MM_*
+modules except ExtUtils::MM_Any chosen based on your operating system.
+
+NOTE: The main object used by MakeMaker is a PACK### object, *not*
+ExtUtils::MakeMaker.  It is, effectively, a subclass of MY,
+ExtUtils::Makemaker, ExtUtils::Liblist and ExtUtils::MM_{Current OS}
+
+NOTE: The methods in MY are simply copied into PACK### rather than
+MY being a superclass of PACK###.  I don't remember the rationale.
+
+NOTE: ExtUtils::Liblist should be removed from the inheritance hiearchy
+and simply be called as functions.
+
+NOTE: Modules like File::Spec and Exporter have been omitted for clarity.
+
+
+=head2 The MM_* hierarchy
+
+                                MM_Win95   MM_NW5
+                                     \      /
+ MM_BeOS  MM_Cygwin  MM_OS2  MM_VMS  MM_Win32  MM_DOS  MM_UWIN
+       \        |      |         |        /      /      /
+        ------------------------------------------------
+                           |       |
+                        MM_Unix    |
+                              |    |
+                              MM_Any
+
+NOTE: Each direct MM_Unix subclass is also an MM_Any subclass.  This
+is a temporary hack because MM_Unix overrides some MM_Any methods with
+Unix specific code.  It allows the non-Unix modules to see the
+original MM_Any implementations.
+
+NOTE: Modules like File::Spec and Exporter have been omitted for clarity.
+
+=head1 PATCHING
+
+If you have a question you'd like to see added to the FAQ (whether or
+not you have the answer) please either:
+
+=over 2
+
+=item * make a pull request on the MakeMaker github repository
+
+=item * raise a issue on the MakeMaker github repository
+
+=item * file an RT ticket
+
+=item * email [email protected]
+
+=back
+
+=head1 AUTHOR
+
+The denizens of [email protected].
+
+=head1 SEE ALSO
+
+L<ExtUtils::MakeMaker>
+
+=cut

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/ParseXS/Constants.pm

@@ -0,0 +1,44 @@
+package ExtUtils::ParseXS::Constants;
+use strict;
+use warnings;
+use Symbol;
+
+our $VERSION = '3.40';
+
+=head1 NAME
+
+ExtUtils::ParseXS::Constants - Initialization values for some globals
+
+=head1 SYNOPSIS
+
+  use ExtUtils::ParseXS::Constants ();
+
+  $PrototypeRegexp = $ExtUtils::ParseXS::Constants::PrototypeRegexp;
+
+=head1 DESCRIPTION
+
+Initialization of certain non-subroutine variables in ExtUtils::ParseXS and some of its
+supporting packages has been moved into this package so that those values can
+be defined exactly once and then re-used in any package.
+
+Nothing is exported.  Use fully qualified variable names.
+
+=cut
+
+# FIXME: THESE ARE NOT CONSTANTS!
+our @InitFileCode;
+
+# Note that to reduce maintenance, $PrototypeRegexp is used
+# by ExtUtils::Typemaps, too!
+our $PrototypeRegexp = "[" . quotemeta('\$%&*@;[]_') . "]";
+our @XSKeywords      = qw( 
+  REQUIRE BOOT CASE PREINIT INPUT INIT CODE PPCODE
+  OUTPUT CLEANUP ALIAS ATTRS PROTOTYPES PROTOTYPE
+  VERSIONCHECK INCLUDE INCLUDE_COMMAND SCOPE INTERFACE
+  INTERFACE_MACRO C_ARGS POSTCALL OVERLOAD FALLBACK
+  EXPORT_XSUB_SYMBOLS
+);
+
+our $XSKeywordsAlternation = join('|', @XSKeywords);
+
+1;

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/ParseXS/CountLines.pm

@@ -0,0 +1,54 @@
+package ExtUtils::ParseXS::CountLines;
+use strict;
+
+our $VERSION = '3.40';
+
+our $SECTION_END_MARKER;
+
+sub TIEHANDLE {
+  my ($class, $cfile, $fh) = @_;
+  $cfile =~ s/\\/\\\\/g;
+  $cfile =~ s/"/\\"/g;
+  $SECTION_END_MARKER = qq{#line --- "$cfile"};
+
+  return bless {
+    buffer => '',
+    fh => $fh,
+    line_no => 1,
+  }, $class;
+}
+
+sub PRINT {
+  my $self = shift;
+  for (@_) {
+    $self->{buffer} .= $_;
+    while ($self->{buffer} =~ s/^([^\n]*\n)//) {
+      my $line = $1;
+      ++$self->{line_no};
+      $line =~ s|^\#line\s+---(?=\s)|#line $self->{line_no}|;
+      print {$self->{fh}} $line;
+    }
+  }
+}
+
+sub PRINTF {
+  my $self = shift;
+  my $fmt = shift;
+  $self->PRINT(sprintf($fmt, @_));
+}
+
+sub DESTROY {
+  # Not necessary if we're careful to end with a "\n"
+  my $self = shift;
+  print {$self->{fh}} $self->{buffer};
+}
+
+sub UNTIE {
+  # This sub does nothing, but is necessary for references to be released.
+}
+
+sub end_marker {
+  return $SECTION_END_MARKER;
+}
+
+1;

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/ParseXS/Eval.pm

@@ -0,0 +1,97 @@
+package ExtUtils::ParseXS::Eval;
+use strict;
+use warnings;
+
+our $VERSION = '3.40';
+
+=head1 NAME
+
+ExtUtils::ParseXS::Eval - Clean package to evaluate code in
+
+=head1 SYNOPSIS
+
+  use ExtUtils::ParseXS::Eval;
+  my $rv = ExtUtils::ParseXS::Eval::eval_typemap_code(
+    $parsexs_obj, "some Perl code"
+  );
+
+=head1 SUBROUTINES
+
+=head2 $pxs->eval_output_typemap_code($typemapcode, $other_hashref)
+
+Sets up various bits of previously global state
+(formerly ExtUtils::ParseXS package variables)
+for eval'ing output typemap code that may refer to these
+variables.
+
+Warns the contents of C<$@> if any.
+
+Not all these variables are necessarily considered "public" wrt. use in
+typemaps, so beware. Variables set up from the ExtUtils::ParseXS object:
+
+  $Package $ALIAS $func_name $Full_func_name $pname
+
+Variables set up from C<$other_hashref>:
+
+  $var $type $ntype $subtype $arg
+
+=cut
+
+sub eval_output_typemap_code {
+  my ($_pxs, $_code, $_other) = @_;
+
+  my ($Package, $ALIAS, $func_name, $Full_func_name, $pname)
+    = @{$_pxs}{qw(Package ALIAS func_name Full_func_name pname)};
+
+  my ($var, $type, $ntype, $subtype, $arg)
+    = @{$_other}{qw(var type ntype subtype arg)};
+
+  my $rv = eval $_code;
+  warn $@ if $@;
+  return $rv;
+}
+
+=head2 $pxs->eval_input_typemap_code($typemapcode, $other_hashref)
+
+Sets up various bits of previously global state
+(formerly ExtUtils::ParseXS package variables)
+for eval'ing output typemap code that may refer to these
+variables.
+
+Warns the contents of C<$@> if any.
+
+Not all these variables are necessarily considered "public" wrt. use in
+typemaps, so beware. Variables set up from the ExtUtils::ParseXS object:
+
+  $Package $ALIAS $func_name $Full_func_name $pname
+
+Variables set up from C<$other_hashref>:
+
+  $var $type $ntype $subtype $num $init $printed_name $arg $argoff
+
+=cut
+
+sub eval_input_typemap_code {
+  my ($_pxs, $_code, $_other) = @_;
+
+  my ($Package, $ALIAS, $func_name, $Full_func_name, $pname)
+    = @{$_pxs}{qw(Package ALIAS func_name Full_func_name pname)};
+
+  my ($var, $type, $num, $init, $printed_name, $arg, $ntype, $argoff, $subtype)
+    = @{$_other}{qw(var type num init printed_name arg ntype argoff subtype)};
+
+  my $rv = eval $_code;
+  warn $@ if $@;
+  return $rv;
+}
+
+=head1 TODO
+
+Eventually, with better documentation and possible some cleanup,
+this could be part of C<ExtUtils::Typemaps>.
+
+=cut
+
+1;
+
+# vim: ts=2 sw=2 et:

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/ParseXS/Utilities.pm

@@ -0,0 +1,821 @@
+package ExtUtils::ParseXS::Utilities;
+use strict;
+use warnings;
+use Exporter;
+use File::Spec;
+use ExtUtils::ParseXS::Constants ();
+
+our $VERSION = '3.40';
+
+our (@ISA, @EXPORT_OK);
+@ISA = qw(Exporter);
+@EXPORT_OK = qw(
+  standard_typemap_locations
+  trim_whitespace
+  C_string
+  valid_proto_string
+  process_typemaps
+  map_type
+  standard_XS_defs
+  assign_func_args
+  analyze_preprocessor_statements
+  set_cond
+  Warn
+  current_line_number
+  blurt
+  death
+  check_conditional_preprocessor_statements
+  escape_file_for_line_directive
+  report_typemap_failure
+);
+
+=head1 NAME
+
+ExtUtils::ParseXS::Utilities - Subroutines used with ExtUtils::ParseXS
+
+=head1 SYNOPSIS
+
+  use ExtUtils::ParseXS::Utilities qw(
+    standard_typemap_locations
+    trim_whitespace
+    C_string
+    valid_proto_string
+    process_typemaps
+    map_type
+    standard_XS_defs
+    assign_func_args
+    analyze_preprocessor_statements
+    set_cond
+    Warn
+    blurt
+    death
+    check_conditional_preprocessor_statements
+    escape_file_for_line_directive
+    report_typemap_failure
+  );
+
+=head1 SUBROUTINES
+
+The following functions are not considered to be part of the public interface.
+They are documented here for the benefit of future maintainers of this module.
+
+=head2 C<standard_typemap_locations()>
+
+=over 4
+
+=item * Purpose
+
+Provide a list of filepaths where F<typemap> files may be found.  The
+filepaths -- relative paths to files (not just directory paths) -- appear in this list in lowest-to-highest priority.
+
+The highest priority is to look in the current directory.  
+
+  'typemap'
+
+The second and third highest priorities are to look in the parent of the
+current directory and a directory called F<lib/ExtUtils> underneath the parent
+directory.
+
+  '../typemap',
+  '../lib/ExtUtils/typemap',
+
+The fourth through ninth highest priorities are to look in the corresponding
+grandparent, great-grandparent and great-great-grandparent directories.
+
+  '../../typemap',
+  '../../lib/ExtUtils/typemap',
+  '../../../typemap',
+  '../../../lib/ExtUtils/typemap',
+  '../../../../typemap',
+  '../../../../lib/ExtUtils/typemap',
+
+The tenth and subsequent priorities are to look in directories named
+F<ExtUtils> which are subdirectories of directories found in C<@INC> --
+I<provided> a file named F<typemap> actually exists in such a directory.
+Example:
+
+  '/usr/local/lib/perl5/5.10.1/ExtUtils/typemap',
+
+However, these filepaths appear in the list returned by
+C<standard_typemap_locations()> in reverse order, I<i.e.>, lowest-to-highest.
+
+  '/usr/local/lib/perl5/5.10.1/ExtUtils/typemap',
+  '../../../../lib/ExtUtils/typemap',
+  '../../../../typemap',
+  '../../../lib/ExtUtils/typemap',
+  '../../../typemap',
+  '../../lib/ExtUtils/typemap',
+  '../../typemap',
+  '../lib/ExtUtils/typemap',
+  '../typemap',
+  'typemap'
+
+=item * Arguments
+
+  my @stl = standard_typemap_locations( \@INC );
+
+Reference to C<@INC>.
+
+=item * Return Value
+
+Array holding list of directories to be searched for F<typemap> files.
+
+=back
+
+=cut
+
+SCOPE: {
+  my @tm_template;
+
+  sub standard_typemap_locations {
+    my $include_ref = shift;
+
+    if (not @tm_template) {
+      @tm_template = qw(typemap);
+
+      my $updir = File::Spec->updir();
+      foreach my $dir (
+          File::Spec->catdir(($updir) x 1),
+          File::Spec->catdir(($updir) x 2),
+          File::Spec->catdir(($updir) x 3),
+          File::Spec->catdir(($updir) x 4),
+      ) {
+        unshift @tm_template, File::Spec->catfile($dir, 'typemap');
+        unshift @tm_template, File::Spec->catfile($dir, lib => ExtUtils => 'typemap');
+      }
+    }
+
+    my @tm = @tm_template;
+    foreach my $dir (@{ $include_ref}) {
+      my $file = File::Spec->catfile($dir, ExtUtils => 'typemap');
+      unshift @tm, $file if -e $file;
+    }
+    return @tm;
+  }
+} # end SCOPE
+
+=head2 C<trim_whitespace()>
+
+=over 4
+
+=item * Purpose
+
+Perform an in-place trimming of leading and trailing whitespace from the
+first argument provided to the function.
+
+=item * Argument
+
+  trim_whitespace($arg);
+
+=item * Return Value
+
+None.  Remember:  this is an I<in-place> modification of the argument.
+
+=back
+
+=cut
+
+sub trim_whitespace {
+  $_[0] =~ s/^\s+|\s+$//go;
+}
+
+=head2 C<C_string()>
+
+=over 4
+
+=item * Purpose
+
+Escape backslashes (C<\>) in prototype strings.
+
+=item * Arguments
+
+      $ProtoThisXSUB = C_string($_);
+
+String needing escaping.
+
+=item * Return Value
+
+Properly escaped string.
+
+=back
+
+=cut
+
+sub C_string {
+  my($string) = @_;
+
+  $string =~ s[\\][\\\\]g;
+  $string;
+}
+
+=head2 C<valid_proto_string()>
+
+=over 4
+
+=item * Purpose
+
+Validate prototype string.
+
+=item * Arguments
+
+String needing checking.
+
+=item * Return Value
+
+Upon success, returns the same string passed as argument.
+
+Upon failure, returns C<0>.
+
+=back
+
+=cut
+
+sub valid_proto_string {
+  my ($string) = @_;
+
+  if ( $string =~ /^$ExtUtils::ParseXS::Constants::PrototypeRegexp+$/ ) {
+    return $string;
+  }
+
+  return 0;
+}
+
+=head2 C<process_typemaps()>
+
+=over 4
+
+=item * Purpose
+
+Process all typemap files.
+
+=item * Arguments
+
+  my $typemaps_object = process_typemaps( $args{typemap}, $pwd );
+
+List of two elements:  C<typemap> element from C<%args>; current working
+directory.
+
+=item * Return Value
+
+Upon success, returns an L<ExtUtils::Typemaps> object.
+
+=back
+
+=cut
+
+sub process_typemaps {
+  my ($tmap, $pwd) = @_;
+
+  my @tm = ref $tmap ? @{$tmap} : ($tmap);
+
+  foreach my $typemap (@tm) {
+    die "Can't find $typemap in $pwd\n" unless -r $typemap;
+  }
+
+  push @tm, standard_typemap_locations( \@INC );
+
+  require ExtUtils::Typemaps;
+  my $typemap = ExtUtils::Typemaps->new;
+  foreach my $typemap_loc (@tm) {
+    next unless -f $typemap_loc;
+    # skip directories, binary files etc.
+    warn("Warning: ignoring non-text typemap file '$typemap_loc'\n"), next
+      unless -T $typemap_loc;
+
+    $typemap->merge(file => $typemap_loc, replace => 1);
+  }
+
+  return $typemap;
+}
+
+=head2 C<map_type()>
+
+=over 4
+
+=item * Purpose
+
+Performs a mapping at several places inside C<PARAGRAPH> loop.
+
+=item * Arguments
+
+  $type = map_type($self, $type, $varname);
+
+List of three arguments.
+
+=item * Return Value
+
+String holding augmented version of second argument.
+
+=back
+
+=cut
+
+sub map_type {
+  my ($self, $type, $varname) = @_;
+
+  # C++ has :: in types too so skip this
+  $type =~ tr/:/_/ unless $self->{RetainCplusplusHierarchicalTypes};
+  $type =~ s/^array\(([^,]*),(.*)\).*/$1 */s;
+  if ($varname) {
+    if ($type =~ / \( \s* \* (?= \s* \) ) /xg) {
+      (substr $type, pos $type, 0) = " $varname ";
+    }
+    else {
+      $type .= "\t$varname";
+    }
+  }
+  return $type;
+}
+
+=head2 C<standard_XS_defs()>
+
+=over 4
+
+=item * Purpose
+
+Writes to the C<.c> output file certain preprocessor directives and function
+headers needed in all such files.
+
+=item * Arguments
+
+None.
+
+=item * Return Value
+
+Returns true.
+
+=back
+
+=cut
+
+sub standard_XS_defs {
+  print <<"EOF";
+#ifndef PERL_UNUSED_VAR
+#  define PERL_UNUSED_VAR(var) if (0) var = var
+#endif
+
+#ifndef dVAR
+#  define dVAR		dNOOP
+#endif
+
+
+/* This stuff is not part of the API! You have been warned. */
+#ifndef PERL_VERSION_DECIMAL
+#  define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s)
+#endif
+#ifndef PERL_DECIMAL_VERSION
+#  define PERL_DECIMAL_VERSION \\
+	  PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION)
+#endif
+#ifndef PERL_VERSION_GE
+#  define PERL_VERSION_GE(r,v,s) \\
+	  (PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s))
+#endif
+#ifndef PERL_VERSION_LE
+#  define PERL_VERSION_LE(r,v,s) \\
+	  (PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s))
+#endif
+
+/* XS_INTERNAL is the explicit static-linkage variant of the default
+ * XS macro.
+ *
+ * XS_EXTERNAL is the same as XS_INTERNAL except it does not include
+ * "STATIC", ie. it exports XSUB symbols. You probably don't want that
+ * for anything but the BOOT XSUB.
+ *
+ * See XSUB.h in core!
+ */
+
+
+/* TODO: This might be compatible further back than 5.10.0. */
+#if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1)
+#  undef XS_EXTERNAL
+#  undef XS_INTERNAL
+#  if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING)
+#    define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name)
+#    define XS_INTERNAL(name) STATIC XSPROTO(name)
+#  endif
+#  if defined(__SYMBIAN32__)
+#    define XS_EXTERNAL(name) EXPORT_C XSPROTO(name)
+#    define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name)
+#  endif
+#  ifndef XS_EXTERNAL
+#    if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus)
+#      define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
+#      define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
+#    else
+#      ifdef __cplusplus
+#        define XS_EXTERNAL(name) extern "C" XSPROTO(name)
+#        define XS_INTERNAL(name) static XSPROTO(name)
+#      else
+#        define XS_EXTERNAL(name) XSPROTO(name)
+#        define XS_INTERNAL(name) STATIC XSPROTO(name)
+#      endif
+#    endif
+#  endif
+#endif
+
+/* perl >= 5.10.0 && perl <= 5.15.1 */
+
+
+/* The XS_EXTERNAL macro is used for functions that must not be static
+ * like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL
+ * macro defined, the best we can do is assume XS is the same.
+ * Dito for XS_INTERNAL.
+ */
+#ifndef XS_EXTERNAL
+#  define XS_EXTERNAL(name) XS(name)
+#endif
+#ifndef XS_INTERNAL
+#  define XS_INTERNAL(name) XS(name)
+#endif
+
+/* Now, finally, after all this mess, we want an ExtUtils::ParseXS
+ * internal macro that we're free to redefine for varying linkage due
+ * to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use
+ * XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to!
+ */
+
+#undef XS_EUPXS
+#if defined(PERL_EUPXS_ALWAYS_EXPORT)
+#  define XS_EUPXS(name) XS_EXTERNAL(name)
+#else
+   /* default to internal */
+#  define XS_EUPXS(name) XS_INTERNAL(name)
+#endif
+
+EOF
+
+  print <<"EOF";
+#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
+#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)
+
+/* prototype to pass -Wmissing-prototypes */
+STATIC void
+S_croak_xs_usage(const CV *const cv, const char *const params);
+
+STATIC void
+S_croak_xs_usage(const CV *const cv, const char *const params)
+{
+    const GV *const gv = CvGV(cv);
+
+    PERL_ARGS_ASSERT_CROAK_XS_USAGE;
+
+    if (gv) {
+        const char *const gvname = GvNAME(gv);
+        const HV *const stash = GvSTASH(gv);
+        const char *const hvname = stash ? HvNAME(stash) : NULL;
+
+        if (hvname)
+	    Perl_croak_nocontext("Usage: %s::%s(%s)", hvname, gvname, params);
+        else
+	    Perl_croak_nocontext("Usage: %s(%s)", gvname, params);
+    } else {
+        /* Pants. I don't think that it should be possible to get here. */
+	Perl_croak_nocontext("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
+    }
+}
+#undef  PERL_ARGS_ASSERT_CROAK_XS_USAGE
+
+#define croak_xs_usage        S_croak_xs_usage
+
+#endif
+
+/* NOTE: the prototype of newXSproto() is different in versions of perls,
+ * so we define a portable version of newXSproto()
+ */
+#ifdef newXS_flags
+#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0)
+#else
+#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv)
+#endif /* !defined(newXS_flags) */
+
+#if PERL_VERSION_LE(5, 21, 5)
+#  define newXS_deffile(a,b) Perl_newXS(aTHX_ a,b,file)
+#else
+#  define newXS_deffile(a,b) Perl_newXS_deffile(aTHX_ a,b)
+#endif
+
+EOF
+  return 1;
+}
+
+=head2 C<assign_func_args()>
+
+=over 4
+
+=item * Purpose
+
+Perform assignment to the C<func_args> attribute.
+
+=item * Arguments
+
+  $string = assign_func_args($self, $argsref, $class);
+
+List of three elements.  Second is an array reference; third is a string.
+
+=item * Return Value
+
+String.
+
+=back
+
+=cut
+
+sub assign_func_args {
+  my ($self, $argsref, $class) = @_;
+  my @func_args = @{$argsref};
+  shift @func_args if defined($class);
+
+  for my $arg (@func_args) {
+    $arg =~ s/^/&/ if $self->{in_out}->{$arg};
+  }
+  return join(", ", @func_args);
+}
+
+=head2 C<analyze_preprocessor_statements()>
+
+=over 4
+
+=item * Purpose
+
+Within each function inside each Xsub, print to the F<.c> output file certain
+preprocessor statements.
+
+=item * Arguments
+
+      ( $self, $XSS_work_idx, $BootCode_ref ) =
+        analyze_preprocessor_statements(
+          $self, $statement, $XSS_work_idx, $BootCode_ref
+        );
+
+List of four elements.
+
+=item * Return Value
+
+Modifed values of three of the arguments passed to the function.  In
+particular, the C<XSStack> and C<InitFileCode> attributes are modified.
+
+=back
+
+=cut
+
+sub analyze_preprocessor_statements {
+  my ($self, $statement, $XSS_work_idx, $BootCode_ref) = @_;
+
+  if ($statement eq 'if') {
+    $XSS_work_idx = @{ $self->{XSStack} };
+    push(@{ $self->{XSStack} }, {type => 'if'});
+  }
+  else {
+    $self->death("Error: '$statement' with no matching 'if'")
+      if $self->{XSStack}->[-1]{type} ne 'if';
+    if ($self->{XSStack}->[-1]{varname}) {
+      push(@{ $self->{InitFileCode} }, "#endif\n");
+      push(@{ $BootCode_ref },     "#endif");
+    }
+
+    my(@fns) = keys %{$self->{XSStack}->[-1]{functions}};
+    if ($statement ne 'endif') {
+      # Hide the functions defined in other #if branches, and reset.
+      @{$self->{XSStack}->[-1]{other_functions}}{@fns} = (1) x @fns;
+      @{$self->{XSStack}->[-1]}{qw(varname functions)} = ('', {});
+    }
+    else {
+      my($tmp) = pop(@{ $self->{XSStack} });
+      0 while (--$XSS_work_idx
+           && $self->{XSStack}->[$XSS_work_idx]{type} ne 'if');
+      # Keep all new defined functions
+      push(@fns, keys %{$tmp->{other_functions}});
+      @{$self->{XSStack}->[$XSS_work_idx]{functions}}{@fns} = (1) x @fns;
+    }
+  }
+  return ($self, $XSS_work_idx, $BootCode_ref);
+}
+
+=head2 C<set_cond()>
+
+=over 4
+
+=item * Purpose
+
+=item * Arguments
+
+=item * Return Value
+
+=back
+
+=cut
+
+sub set_cond {
+  my ($ellipsis, $min_args, $num_args) = @_;
+  my $cond;
+  if ($ellipsis) {
+    $cond = ($min_args ? qq(items < $min_args) : 0);
+  }
+  elsif ($min_args == $num_args) {
+    $cond = qq(items != $min_args);
+  }
+  else {
+    $cond = qq(items < $min_args || items > $num_args);
+  }
+  return $cond;
+}
+
+=head2 C<current_line_number()>
+
+=over 4
+
+=item * Purpose
+
+Figures out the current line number in the XS file.
+
+=item * Arguments
+
+C<$self>
+
+=item * Return Value
+
+The current line number.
+
+=back
+
+=cut
+
+sub current_line_number {
+  my $self = shift;
+  my $line_number = $self->{line_no}->[@{ $self->{line_no} } - @{ $self->{line} } -1];
+  return $line_number;
+}
+
+=head2 C<Warn()>
+
+=over 4
+
+=item * Purpose
+
+=item * Arguments
+
+=item * Return Value
+
+=back
+
+=cut
+
+sub Warn {
+  my $self = shift;
+  my $warn_line_number = $self->current_line_number();
+  print STDERR "@_ in $self->{filename}, line $warn_line_number\n";
+}
+
+=head2 C<blurt()>
+
+=over 4
+
+=item * Purpose
+
+=item * Arguments
+
+=item * Return Value
+
+=back
+
+=cut
+
+sub blurt {
+  my $self = shift;
+  $self->Warn(@_);
+  $self->{errors}++
+}
+
+=head2 C<death()>
+
+=over 4
+
+=item * Purpose
+
+=item * Arguments
+
+=item * Return Value
+
+=back
+
+=cut
+
+sub death {
+  my $self = shift;
+  $self->Warn(@_);
+  exit 1;
+}
+
+=head2 C<check_conditional_preprocessor_statements()>
+
+=over 4
+
+=item * Purpose
+
+=item * Arguments
+
+=item * Return Value
+
+=back
+
+=cut
+
+sub check_conditional_preprocessor_statements {
+  my ($self) = @_;
+  my @cpp = grep(/^\#\s*(?:if|e\w+)/, @{ $self->{line} });
+  if (@cpp) {
+    my $cpplevel;
+    for my $cpp (@cpp) {
+      if ($cpp =~ /^\#\s*if/) {
+        $cpplevel++;
+      }
+      elsif (!$cpplevel) {
+        $self->Warn("Warning: #else/elif/endif without #if in this function");
+        print STDERR "    (precede it with a blank line if the matching #if is outside the function)\n"
+          if $self->{XSStack}->[-1]{type} eq 'if';
+        return;
+      }
+      elsif ($cpp =~ /^\#\s*endif/) {
+        $cpplevel--;
+      }
+    }
+    $self->Warn("Warning: #if without #endif in this function") if $cpplevel;
+  }
+}
+
+=head2 C<escape_file_for_line_directive()>
+
+=over 4
+
+=item * Purpose
+
+Escapes a given code source name (typically a file name but can also
+be a command that was read from) so that double-quotes and backslashes are escaped.
+
+=item * Arguments
+
+A string.
+
+=item * Return Value
+
+A string with escapes for double-quotes and backslashes.
+
+=back
+
+=cut
+
+sub escape_file_for_line_directive {
+  my $string = shift;
+  $string =~ s/\\/\\\\/g;
+  $string =~ s/"/\\"/g;
+  return $string;
+}
+
+=head2 C<report_typemap_failure>
+
+=over 4
+
+=item * Purpose
+
+Do error reporting for missing typemaps.
+
+=item * Arguments
+
+The C<ExtUtils::ParseXS> object.
+
+An C<ExtUtils::Typemaps> object.
+
+The string that represents the C type that was not found in the typemap.
+
+Optionally, the string C<death> or C<blurt> to choose
+whether the error is immediately fatal or not. Default: C<blurt>
+
+=item * Return Value
+
+Returns nothing. Depending on the arguments, this
+may call C<death> or C<blurt>, the former of which is
+fatal.
+
+=back
+
+=cut
+
+sub report_typemap_failure {
+  my ($self, $tm, $ctype, $error_method) = @_;
+  $error_method ||= 'blurt';
+
+  my @avail_ctypes = $tm->list_mapped_ctypes;
+
+  my $err = "Could not find a typemap for C type '$ctype'.\n"
+            . "The following C types are mapped by the current typemap:\n'"
+            . join("', '", @avail_ctypes) . "'\n";
+
+  $self->$error_method($err);
+  return();
+}
+
+1;
+
+# vim: ts=2 sw=2 et:

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/Typemaps/Cmd.pm

@@ -0,0 +1,168 @@
+package ExtUtils::Typemaps::Cmd;
+use 5.006001;
+use strict;
+use warnings;
+our $VERSION = '3.38';
+
+use ExtUtils::Typemaps;
+
+require Exporter;
+
+our @ISA = qw(Exporter);
+our @EXPORT = qw(embeddable_typemap);
+our %EXPORT_TAGS = (all => \@EXPORT);
+
+sub embeddable_typemap {
+  my @tms = @_;
+
+  # Get typemap objects
+  my @tm_objs = map [$_, _intuit_typemap_source($_)], @tms;
+
+  # merge or short-circuit
+  my $final_tm;
+  if (@tm_objs == 1) {
+    # just one, merge would be pointless
+    $final_tm = shift(@tm_objs)->[1];
+  }
+  else {
+    # multiple, need merge
+    $final_tm = ExtUtils::Typemaps->new;
+    foreach my $other_tm (@tm_objs) {
+      my ($tm_ident, $tm_obj) = @$other_tm;
+      eval {
+        $final_tm->merge(typemap => $tm_obj);
+        1
+      } or do {
+        my $err = $@ || 'Zombie error';
+        die "Failed to merge typ";
+      }
+    }
+  }
+
+  # stringify for embedding
+  return $final_tm->as_embedded_typemap();
+}
+
+sub _load_module {
+  my $name = shift;
+  return eval "require $name; 1";
+}
+
+SCOPE: {
+  my %sources = (
+    module => sub {
+      my $ident = shift;
+      my $tm;
+      if (/::/) { # looks like FQ module name, try that first
+        foreach my $module ($ident, "ExtUtils::Typemaps::$ident") {
+          if (_load_module($module)) {
+            eval { $tm = $module->new }
+              and return $tm;
+          }
+        }
+      }
+      else {
+        foreach my $module ("ExtUtils::Typemaps::$ident", "$ident") {
+          if (_load_module($module)) {
+            eval { $tm = $module->new }
+              and return $tm;
+          }
+        }
+      }
+      return();
+    },
+    file => sub {
+      my $ident = shift;
+      return unless -e $ident and -r _;
+      return ExtUtils::Typemaps->new(file => $ident);
+    },
+  );
+  # Try to find typemap either from module or file
+  sub _intuit_typemap_source {
+    my $identifier = shift;
+
+    my @locate_attempts;
+    if ($identifier =~ /::/ || $identifier !~ /[^\w_]/) {
+      @locate_attempts = qw(module file);
+    }
+    else {
+      @locate_attempts = qw(file module);
+    }
+
+    foreach my $source (@locate_attempts) {
+      my $tm = $sources{$source}->($identifier);
+      return $tm if defined $tm;
+    }
+
+    die "Unable to find typemap for '$identifier': "
+        . "Tried to load both as file or module and failed.\n";
+  }
+} # end SCOPE
+
+=head1 NAME
+
+ExtUtils::Typemaps::Cmd - Quick commands for handling typemaps
+
+=head1 SYNOPSIS
+
+From XS:
+
+  INCLUDE_COMMAND: $^X -MExtUtils::Typemaps::Cmd \
+                   -e "print embeddable_typemap(q{Excommunicated})"
+
+Loads C<ExtUtils::Typemaps::Excommunicated>, instantiates an object,
+and dumps it as an embeddable typemap for use directly in your XS file.
+
+=head1 DESCRIPTION
+
+This is a helper module for L<ExtUtils::Typemaps> for quick
+one-liners, specifically for inclusion of shared typemaps
+that live on CPAN into an XS file (see SYNOPSIS).
+
+For this reason, the following functions are exported by default:
+
+=head1 EXPORTED FUNCTIONS
+
+=head2 embeddable_typemap
+
+Given a list of identifiers, C<embeddable_typemap>
+tries to load typemaps from a file of the given name(s),
+or from a module that is an C<ExtUtils::Typemaps> subclass.
+
+Returns a string representation of the merged typemaps that can
+be included verbatim into XS. Example:
+
+  print embeddable_typemap(
+    "Excommunicated", "ExtUtils::Typemaps::Basic", "./typemap"
+  );
+
+This will try to load a module C<ExtUtils::Typemaps::Excommunicated>
+and use it as an C<ExtUtils::Typemaps> subclass. If that fails, it'll
+try loading C<Excommunicated> as a module, if that fails, it'll try to
+read a file called F<Excommunicated>. It'll work similarly for the
+second argument, but the third will be loaded as a file first.
+
+After loading all typemap files or modules, it will merge them in the
+specified order and dump the result as an embeddable typemap.
+
+=head1 SEE ALSO
+
+L<ExtUtils::Typemaps>
+
+L<perlxs>
+
+=head1 AUTHOR
+
+Steffen Mueller C<<[email protected]>>
+
+=head1 COPYRIGHT & LICENSE
+
+Copyright 2012 Steffen Mueller
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+=cut
+
+1;
+

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/Typemaps/InputMap.pm

@@ -0,0 +1,116 @@
+package ExtUtils::Typemaps::InputMap;
+use 5.006001;
+use strict;
+use warnings;
+our $VERSION = '3.38';
+
+=head1 NAME
+
+ExtUtils::Typemaps::InputMap - Entry in the INPUT section of a typemap
+
+=head1 SYNOPSIS
+
+  use ExtUtils::Typemaps;
+  ...
+  my $input = $typemap->get_input_map('T_NV');
+  my $code = $input->code();
+  $input->code("...");
+
+=head1 DESCRIPTION
+
+Refer to L<ExtUtils::Typemaps> for details.
+
+=head1 METHODS
+
+=cut
+
+=head2 new
+
+Requires C<xstype> and C<code> parameters.
+
+=cut
+
+sub new {
+  my $prot = shift;
+  my $class = ref($prot)||$prot;
+  my %args = @_;
+
+  if (!ref($prot)) {
+    if (not defined $args{xstype} or not defined $args{code}) {
+      die("Need xstype and code parameters");
+    }
+  }
+
+  my $self = bless(
+    (ref($prot) ? {%$prot} : {})
+    => $class
+  );
+
+  $self->{xstype} = $args{xstype} if defined $args{xstype};
+  $self->{code} = $args{code} if defined $args{code};
+  $self->{code} =~ s/^(?=\S)/\t/mg;
+
+  return $self;
+}
+
+=head2 code
+
+Returns or sets the INPUT mapping code for this entry.
+
+=cut
+
+sub code {
+  $_[0]->{code} = $_[1] if @_ > 1;
+  return $_[0]->{code};
+}
+
+=head2 xstype
+
+Returns the name of the XS type of the INPUT map.
+
+=cut
+
+sub xstype {
+  return $_[0]->{xstype};
+}
+
+=head2 cleaned_code
+
+Returns a cleaned-up copy of the code to which certain transformations
+have been applied to make it more ANSI compliant.
+
+=cut
+
+sub cleaned_code {
+  my $self = shift;
+  my $code = $self->code;
+
+  $code =~ s/(?:;+\s*|;*\s+)\z//s;
+
+  # Move C pre-processor instructions to column 1 to be strictly ANSI
+  # conformant. Some pre-processors are fussy about this.
+  $code =~ s/^\s+#/#/mg;
+  $code =~ s/\s*\z/\n/;
+
+  return $code;
+}
+
+=head1 SEE ALSO
+
+L<ExtUtils::Typemaps>
+
+=head1 AUTHOR
+
+Steffen Mueller C<<[email protected]>>
+
+=head1 COPYRIGHT & LICENSE
+
+Copyright 2009, 2010, 2011, 2012 Steffen Mueller
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+=cut
+
+1;
+

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/Typemaps/OutputMap.pm

@@ -0,0 +1,209 @@
+package ExtUtils::Typemaps::OutputMap;
+use 5.006001;
+use strict;
+use warnings;
+our $VERSION = '3.38';
+
+=head1 NAME
+
+ExtUtils::Typemaps::OutputMap - Entry in the OUTPUT section of a typemap
+
+=head1 SYNOPSIS
+
+  use ExtUtils::Typemaps;
+  ...
+  my $output = $typemap->get_output_map('T_NV');
+  my $code = $output->code();
+  $output->code("...");
+
+=head1 DESCRIPTION
+
+Refer to L<ExtUtils::Typemaps> for details.
+
+=head1 METHODS
+
+=cut
+
+=head2 new
+
+Requires C<xstype> and C<code> parameters.
+
+=cut
+
+sub new {
+  my $prot = shift;
+  my $class = ref($prot)||$prot;
+  my %args = @_;
+
+  if (!ref($prot)) {
+    if (not defined $args{xstype} or not defined $args{code}) {
+      die("Need xstype and code parameters");
+    }
+  }
+
+  my $self = bless(
+    (ref($prot) ? {%$prot} : {})
+    => $class
+  );
+
+  $self->{xstype} = $args{xstype} if defined $args{xstype};
+  $self->{code} = $args{code} if defined $args{code};
+  $self->{code} =~ s/^(?=\S)/\t/mg;
+
+  return $self;
+}
+
+=head2 code
+
+Returns or sets the OUTPUT mapping code for this entry.
+
+=cut
+
+sub code {
+  $_[0]->{code} = $_[1] if @_ > 1;
+  return $_[0]->{code};
+}
+
+=head2 xstype
+
+Returns the name of the XS type of the OUTPUT map.
+
+=cut
+
+sub xstype {
+  return $_[0]->{xstype};
+}
+
+=head2 cleaned_code
+
+Returns a cleaned-up copy of the code to which certain transformations
+have been applied to make it more ANSI compliant.
+
+=cut
+
+sub cleaned_code {
+  my $self = shift;
+  my $code = $self->code;
+
+  # Move C pre-processor instructions to column 1 to be strictly ANSI
+  # conformant. Some pre-processors are fussy about this.
+  $code =~ s/^\s+#/#/mg;
+  $code =~ s/\s*\z/\n/;
+
+  return $code;
+}
+
+=head2 targetable
+
+This is an obscure but effective optimization that used to
+live in C<ExtUtils::ParseXS> directly. Not implementing it
+should never result in incorrect use of typemaps, just less
+efficient code.
+
+In a nutshell, this will check whether the output code
+involves calling C<sv_setiv>, C<sv_setuv>, C<sv_setnv>, C<sv_setpv> or
+C<sv_setpvn> to set the special C<$arg> placeholder to a new value
+B<AT THE END OF THE OUTPUT CODE>. If that is the case, the code is
+eligible for using the C<TARG>-related macros to optimize this.
+Thus the name of the method: C<targetable>.
+
+If this optimization is applicable, C<ExtUtils::ParseXS> will
+emit a C<dXSTARG;> definition at the start of the generated XSUB code,
+and type (see below) dependent code to set C<TARG> and push it on
+the stack at the end of the generated XSUB code.
+
+If the optimization can not be applied, this returns undef.
+If it can be applied, this method returns a hash reference containing
+the following information:
+
+  type:      Any of the characters i, u, n, p
+  with_size: Bool indicating whether this is the sv_setpvn variant
+  what:      The code that actually evaluates to the output scalar
+  what_size: If "with_size", this has the string length (as code,
+             not constant, including leading comma)
+
+=cut
+
+sub targetable {
+  my $self = shift;
+  return $self->{targetable} if exists $self->{targetable};
+
+  our $bal; # ()-balanced
+  $bal = qr[
+    (?:
+      (?>[^()]+)
+      |
+      \( (??{ $bal }) \)
+    )*
+  ]x;
+  my $bal_no_comma = qr[
+    (?:
+      (?>[^(),]+)
+      |
+      \( (??{ $bal }) \)
+    )+
+  ]x;
+
+  # matches variations on (SV*)
+  my $sv_cast = qr[
+    (?:
+      \( \s* SV \s* \* \s* \) \s*
+    )?
+  ]x;
+
+  my $size = qr[ # Third arg (to setpvn)
+    , \s* (??{ $bal })
+  ]xo;
+
+  my $code = $self->code;
+
+  # We can still bootstrap compile 're', because in code re.pm is
+  # available to miniperl, and does not attempt to load the XS code.
+  use re 'eval';
+
+  my ($type, $with_size, $arg, $sarg) =
+    ($code =~
+      m[^
+        \s+
+        sv_set([iunp])v(n)?    # Type, is_setpvn
+        \s*
+        \( \s*
+          $sv_cast \$arg \s* , \s*
+          ( $bal_no_comma )    # Set from
+          ( $size )?           # Possible sizeof set-from
+        \s* \) \s* ; \s* $
+      ]xo
+  );
+
+  my $rv = undef;
+  if ($type) {
+    $rv = {
+      type      => $type,
+      with_size => $with_size,
+      what      => $arg,
+      what_size => $sarg,
+    };
+  }
+  $self->{targetable} = $rv;
+  return $rv;
+}
+
+=head1 SEE ALSO
+
+L<ExtUtils::Typemaps>
+
+=head1 AUTHOR
+
+Steffen Mueller C<<[email protected]>>
+
+=head1 COPYRIGHT & LICENSE
+
+Copyright 2009, 2010, 2011, 2012 Steffen Mueller
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+=cut
+
+1;
+

my_container_sandbox/usr/share/perl/5.30.0/ExtUtils/Typemaps/Type.pm

@@ -0,0 +1,121 @@
+package ExtUtils::Typemaps::Type;
+use 5.006001;
+use strict;
+use warnings;
+require ExtUtils::Typemaps;
+
+our $VERSION = '3.38';
+
+=head1 NAME
+
+ExtUtils::Typemaps::Type - Entry in the TYPEMAP section of a typemap
+
+=head1 SYNOPSIS
+
+  use ExtUtils::Typemaps;
+  ...
+  my $type = $typemap->get_type_map('char*');
+  my $input = $typemap->get_input_map($type->xstype);
+
+=head1 DESCRIPTION
+
+Refer to L<ExtUtils::Typemaps> for details.
+Object associates C<ctype> with C<xstype>, which is the index
+into the in- and output mapping tables.
+
+=head1 METHODS
+
+=cut
+
+=head2 new
+
+Requires C<xstype> and C<ctype> parameters.
+
+Optionally takes C<prototype> parameter.
+
+=cut
+
+sub new {
+  my $prot = shift;
+  my $class = ref($prot)||$prot;
+  my %args = @_;
+
+  if (!ref($prot)) {
+    if (not defined $args{xstype} or not defined $args{ctype}) {
+      die("Need xstype and ctype parameters");
+    }
+  }
+
+  my $self = bless(
+    (ref($prot) ? {%$prot} : {proto => ''})
+    => $class
+  );
+
+  $self->{xstype} = $args{xstype} if defined $args{xstype};
+  $self->{ctype} = $args{ctype} if defined $args{ctype};
+  $self->{tidy_ctype} = ExtUtils::Typemaps::tidy_type($self->{ctype});
+  $self->{proto} = $args{'prototype'} if defined $args{'prototype'};
+
+  return $self;
+}
+
+=head2 proto
+
+Returns or sets the prototype.
+
+=cut
+
+sub proto {
+  $_[0]->{proto} = $_[1] if @_ > 1;
+  return $_[0]->{proto};
+}
+
+=head2 xstype
+
+Returns the name of the XS type that this C type is associated to.
+
+=cut
+
+sub xstype {
+  return $_[0]->{xstype};
+}
+
+=head2 ctype
+
+Returns the name of the C type as it was set on construction.
+
+=cut
+
+sub ctype {
+  return defined($_[0]->{ctype}) ? $_[0]->{ctype} : $_[0]->{tidy_ctype};
+}
+
+=head2 tidy_ctype
+
+Returns the canonicalized name of the C type.
+
+=cut
+
+sub tidy_ctype {
+  return $_[0]->{tidy_ctype};
+}
+
+=head1 SEE ALSO
+
+L<ExtUtils::Typemaps>
+
+=head1 AUTHOR
+
+Steffen Mueller C<<[email protected]>>
+
+=head1 COPYRIGHT & LICENSE
+
+Copyright 2009, 2010, 2011, 2012 Steffen Mueller
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+=cut
+
+1;
+

my_container_sandbox/usr/share/perl/5.30.0/Test2/API/Breakage.pm

@@ -0,0 +1,178 @@
+package Test2::API::Breakage;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+
+use Test2::Util qw/pkg_to_file/;
+
+our @EXPORT_OK = qw{
+    upgrade_suggested
+    upgrade_required
+    known_broken
+};
+BEGIN { require Exporter; our @ISA = qw(Exporter) }
+
+sub upgrade_suggested {
+    return (
+        'Test::Exception'    => '0.42',
+        'Test::FITesque'     => '0.04',
+        'Test::Module::Used' => '0.2.5',
+        'Test::Moose::More'  => '0.025',
+    );
+}
+
+sub upgrade_required {
+    return (
+        'Test::Builder::Clutch'   => '0.07',
+        'Test::Dist::VersionSync' => '1.1.4',
+        'Test::Modern'            => '0.012',
+        'Test::SharedFork'        => '0.34',
+        'Test::Alien'             => '0.04',
+        'Test::UseAllModules'     => '0.14',
+        'Test::More::Prefix'      => '0.005',
+
+        'Test2::Tools::EventDumper' => 0.000007,
+        'Test2::Harness'            => 0.000013,
+
+        'Test::DBIx::Class::Schema'    => '1.0.9',
+        'Test::Clustericious::Cluster' => '0.30',
+    );
+}
+
+sub known_broken {
+    return (
+        'Net::BitTorrent'       => '0.052',
+        'Test::Able'            => '0.11',
+        'Test::Aggregate'       => '0.373',
+        'Test::Flatten'         => '0.11',
+        'Test::Group'           => '0.20',
+        'Test::ParallelSubtest' => '0.05',
+        'Test::Pretty'          => '0.32',
+        'Test::Wrapper'         => '0.3.0',
+
+        'Log::Dispatch::Config::TestLog' => '0.02',
+    );
+}
+
+# Not reportable:
+# Device::Chip => 0.07   - Tests will not pass, but not broken if already installed, also no fixed version we can upgrade to.
+
+sub report {
+    my $class = shift;
+    my ($require) = @_;
+
+    my %suggest  = __PACKAGE__->upgrade_suggested();
+    my %required = __PACKAGE__->upgrade_required();
+    my %broken   = __PACKAGE__->known_broken();
+
+    my @warn;
+    for my $mod (keys %suggest) {
+        my $file = pkg_to_file($mod);
+        next unless $INC{$file} || ($require && eval { require $file; 1 });
+        my $want = $suggest{$mod};
+        next if eval { $mod->VERSION($want); 1 };
+        push @warn => " * Module '$mod' is outdated, we recommed updating above $want.";
+    }
+
+    for my $mod (keys %required) {
+        my $file = pkg_to_file($mod);
+        next unless $INC{$file} || ($require && eval { require $file; 1 });
+        my $want = $required{$mod};
+        next if eval { $mod->VERSION($want); 1 };
+        push @warn => " * Module '$mod' is outdated and known to be broken, please update to $want or higher.";
+    }
+
+    for my $mod (keys %broken) {
+        my $file = pkg_to_file($mod);
+        next unless $INC{$file} || ($require && eval { require $file; 1 });
+        my $tested = $broken{$mod};
+        push @warn => " * Module '$mod' is known to be broken in version $tested and below, newer versions have not been tested. You have: " . $mod->VERSION;
+    }
+
+    return @warn;
+}
+
+1;
+
+__END__
+
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API::Breakage - What breaks at what version
+
+=head1 DESCRIPTION
+
+This module provides lists of modules that are broken, or have been broken in
+the past, when upgrading L<Test::Builder> to use L<Test2>.
+
+=head1 FUNCTIONS
+
+These can be imported, or called as methods on the class.
+
+=over 4
+
+=item %mod_ver = upgrade_suggested()
+
+=item %mod_ver = Test2::API::Breakage->upgrade_suggested()
+
+This returns key/value pairs. The key is the module name, the value is the
+version number. If the installed version of the module is at or below the
+specified one then an upgrade would be a good idea, but not strictly necessary.
+
+=item %mod_ver = upgrade_required()
+
+=item %mod_ver = Test2::API::Breakage->upgrade_required()
+
+This returns key/value pairs. The key is the module name, the value is the
+version number. If the installed version of the module is at or below the
+specified one then an upgrade is required for the module to work properly.
+
+=item %mod_ver = known_broken()
+
+=item %mod_ver = Test2::API::Breakage->known_broken()
+
+This returns key/value pairs. The key is the module name, the value is the
+version number. If the installed version of the module is at or below the
+specified one then the module will not work. A newer version may work, but is
+not tested or verified.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/API/Context.pm

@@ -0,0 +1,1013 @@
+package Test2::API::Context;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+
+use Carp qw/confess croak/;
+use Scalar::Util qw/weaken blessed/;
+use Test2::Util qw/get_tid try pkg_to_file get_tid/;
+
+use Test2::EventFacet::Trace();
+use Test2::API();
+
+# Preload some key event types
+my %LOADED = (
+    map {
+        my $pkg  = "Test2::Event::$_";
+        my $file = "Test2/Event/$_.pm";
+        require $file unless $INC{$file};
+        ( $pkg => $pkg, $_ => $pkg )
+    } qw/Ok Diag Note Plan Bail Exception Waiting Skip Subtest Pass Fail V2/
+);
+
+use Test2::Util::ExternalMeta qw/meta get_meta set_meta delete_meta/;
+use Test2::Util::HashBase qw{
+    stack hub trace _on_release _depth _is_canon _is_spawn _aborted
+    errno eval_error child_error thrown
+};
+
+# Private, not package vars
+# It is safe to cache these.
+my $ON_RELEASE = Test2::API::_context_release_callbacks_ref();
+my $CONTEXTS   = Test2::API::_contexts_ref();
+
+sub init {
+    my $self = shift;
+
+    confess "The 'trace' attribute is required"
+        unless $self->{+TRACE};
+
+    confess "The 'hub' attribute is required"
+        unless $self->{+HUB};
+
+    $self->{+_DEPTH} = 0 unless defined $self->{+_DEPTH};
+
+    $self->{+ERRNO}       = $! unless exists $self->{+ERRNO};
+    $self->{+EVAL_ERROR}  = $@ unless exists $self->{+EVAL_ERROR};
+    $self->{+CHILD_ERROR} = $? unless exists $self->{+CHILD_ERROR};
+}
+
+sub snapshot { bless {%{$_[0]}, _is_canon => undef, _is_spawn => undef, _aborted => undef}, __PACKAGE__ }
+
+sub restore_error_vars {
+    my $self = shift;
+    ($!, $@, $?) = @$self{+ERRNO, +EVAL_ERROR, +CHILD_ERROR};
+}
+
+sub DESTROY {
+    return unless $_[0]->{+_IS_CANON} || $_[0]->{+_IS_SPAWN};
+    return if $_[0]->{+_ABORTED} && ${$_[0]->{+_ABORTED}};
+    my ($self) = @_;
+
+    my $hub = $self->{+HUB};
+    my $hid = $hub->{hid};
+
+    # Do not show the warning if it looks like an exception has been thrown, or
+    # if the context is not local to this process or thread.
+    {
+        # Sometimes $@ is uninitialized, not a problem in this case so do not
+        # show the warning about using eq.
+        no warnings 'uninitialized';
+        if($self->{+EVAL_ERROR} eq $@ && $hub->is_local) {
+            my $frame = $self->{+_IS_SPAWN} || $self->{+TRACE}->frame;
+            warn <<"            EOT";
+A context appears to have been destroyed without first calling release().
+Based on \$@ it does not look like an exception was thrown (this is not always
+a reliable test)
+
+This is a problem because the global error variables (\$!, \$@, and \$?) will
+not be restored. In addition some release callbacks will not work properly from
+inside a DESTROY method.
+
+Here are the context creation details, just in case a tool forgot to call
+release():
+  File: $frame->[1]
+  Line: $frame->[2]
+  Tool: $frame->[3]
+
+Cleaning up the CONTEXT stack...
+            EOT
+        }
+    }
+
+    return if $self->{+_IS_SPAWN};
+
+    # Remove the key itself to avoid a slow memory leak
+    delete $CONTEXTS->{$hid};
+    $self->{+_IS_CANON} = undef;
+
+    if (my $cbk = $self->{+_ON_RELEASE}) {
+        $_->($self) for reverse @$cbk;
+    }
+    if (my $hcbk = $hub->{_context_release}) {
+        $_->($self) for reverse @$hcbk;
+    }
+    $_->($self) for reverse @$ON_RELEASE;
+}
+
+# release exists to implement behaviors like die-on-fail. In die-on-fail you
+# want to die after a failure, but only after diagnostics have been reported.
+# The ideal time for the die to happen is when the context is released.
+# Unfortunately die does not work in a DESTROY block.
+sub release {
+    my ($self) = @_;
+
+    ($!, $@, $?) = @$self{+ERRNO, +EVAL_ERROR, +CHILD_ERROR} and return if $self->{+THROWN};
+
+    ($!, $@, $?) = @$self{+ERRNO, +EVAL_ERROR, +CHILD_ERROR} and return $self->{+_IS_SPAWN} = undef
+        if $self->{+_IS_SPAWN};
+
+    croak "release() should not be called on context that is neither canon nor a child"
+        unless $self->{+_IS_CANON};
+
+    my $hub = $self->{+HUB};
+    my $hid = $hub->{hid};
+
+    croak "context thinks it is canon, but it is not"
+        unless $CONTEXTS->{$hid} && $CONTEXTS->{$hid} == $self;
+
+    # Remove the key itself to avoid a slow memory leak
+    $self->{+_IS_CANON} = undef;
+    delete $CONTEXTS->{$hid};
+
+    if (my $cbk = $self->{+_ON_RELEASE}) {
+        $_->($self) for reverse @$cbk;
+    }
+    if (my $hcbk = $hub->{_context_release}) {
+        $_->($self) for reverse @$hcbk;
+    }
+    $_->($self) for reverse @$ON_RELEASE;
+
+    # Do this last so that nothing else changes them.
+    # If one of the hooks dies then these do not get restored, this is
+    # intentional
+    ($!, $@, $?) = @$self{+ERRNO, +EVAL_ERROR, +CHILD_ERROR};
+
+    return;
+}
+
+sub do_in_context {
+    my $self = shift;
+    my ($sub, @args) = @_;
+
+    # We need to update the pid/tid and error vars.
+    my $clone = $self->snapshot;
+    @$clone{+ERRNO, +EVAL_ERROR, +CHILD_ERROR} = ($!, $@, $?);
+    $clone->{+TRACE} = $clone->{+TRACE}->snapshot(pid => $$, tid => get_tid());
+
+    my $hub = $clone->{+HUB};
+    my $hid = $hub->hid;
+
+    my $old = $CONTEXTS->{$hid};
+
+    $clone->{+_IS_CANON} = 1;
+    $CONTEXTS->{$hid} = $clone;
+    weaken($CONTEXTS->{$hid});
+    my ($ok, $err) = &try($sub, @args);
+    my ($rok, $rerr) = try { $clone->release };
+    delete $clone->{+_IS_CANON};
+
+    if ($old) {
+        $CONTEXTS->{$hid} = $old;
+        weaken($CONTEXTS->{$hid});
+    }
+    else {
+        delete $CONTEXTS->{$hid};
+    }
+
+    die $err  unless $ok;
+    die $rerr unless $rok;
+}
+
+sub done_testing {
+    my $self = shift;
+    $self->hub->finalize($self->trace, 1);
+    return;
+}
+
+sub throw {
+    my ($self, $msg) = @_;
+    $self->{+THROWN} = 1;
+    ${$self->{+_ABORTED}}++ if $self->{+_ABORTED};
+    $self->release if $self->{+_IS_CANON} || $self->{+_IS_SPAWN};
+    $self->trace->throw($msg);
+}
+
+sub alert {
+    my ($self, $msg) = @_;
+    $self->trace->alert($msg);
+}
+
+sub send_ev2_and_release {
+    my $self = shift;
+    my $out  = $self->send_ev2(@_);
+    $self->release;
+    return $out;
+}
+
+sub send_ev2 {
+    my $self = shift;
+
+    my $e;
+    {
+        local $Carp::CarpLevel = $Carp::CarpLevel + 1;
+        $e = Test2::Event::V2->new(
+            trace => $self->{+TRACE}->snapshot,
+            @_,
+        );
+    }
+
+    if ($self->{+_ABORTED}) {
+        my $f = $e->facet_data;
+        ${$self->{+_ABORTED}}++ if $f->{control}->{halt} || defined($f->{control}->{terminate}) || defined($e->terminate);
+    }
+    $self->{+HUB}->send($e);
+}
+
+sub build_ev2 {
+    my $self = shift;
+
+    local $Carp::CarpLevel = $Carp::CarpLevel + 1;
+    Test2::Event::V2->new(
+        trace => $self->{+TRACE}->snapshot,
+        @_,
+    );
+}
+
+sub send_event_and_release {
+    my $self = shift;
+    my $out = $self->send_event(@_);
+    $self->release;
+    return $out;
+}
+
+sub send_event {
+    my $self  = shift;
+    my $event = shift;
+    my %args  = @_;
+
+    my $pkg = $LOADED{$event} || $self->_parse_event($event);
+
+    my $e;
+    {
+        local $Carp::CarpLevel = $Carp::CarpLevel + 1;
+        $e = $pkg->new(
+            trace => $self->{+TRACE}->snapshot,
+            %args,
+        );
+    }
+
+    if ($self->{+_ABORTED}) {
+        my $f = $e->facet_data;
+        ${$self->{+_ABORTED}}++ if $f->{control}->{halt} || defined($f->{control}->{terminate}) || defined($e->terminate);
+    }
+    $self->{+HUB}->send($e);
+}
+
+sub build_event {
+    my $self  = shift;
+    my $event = shift;
+    my %args  = @_;
+
+    my $pkg = $LOADED{$event} || $self->_parse_event($event);
+
+    local $Carp::CarpLevel = $Carp::CarpLevel + 1;
+    $pkg->new(
+        trace => $self->{+TRACE}->snapshot,
+        %args,
+    );
+}
+
+sub pass {
+    my $self = shift;
+    my ($name) = @_;
+
+    my $e = bless(
+        {
+            trace => bless({%{$self->{+TRACE}}}, 'Test2::EventFacet::Trace'),
+            name  => $name,
+        },
+        "Test2::Event::Pass"
+    );
+
+    $self->{+HUB}->send($e);
+    return $e;
+}
+
+sub pass_and_release {
+    my $self = shift;
+    my ($name) = @_;
+
+    my $e = bless(
+        {
+            trace => bless({%{$self->{+TRACE}}}, 'Test2::EventFacet::Trace'),
+            name  => $name,
+        },
+        "Test2::Event::Pass"
+    );
+
+    $self->{+HUB}->send($e);
+    $self->release;
+    return 1;
+}
+
+sub fail {
+    my $self = shift;
+    my ($name, @diag) = @_;
+
+    my $e = bless(
+        {
+            trace => bless({%{$self->{+TRACE}}}, 'Test2::EventFacet::Trace'),
+            name  => $name,
+        },
+        "Test2::Event::Fail"
+    );
+
+    for my $msg (@diag) {
+        if (ref($msg) eq 'Test2::EventFacet::Info::Table') {
+            $e->add_info({tag => 'DIAG', debug => 1, $msg->info_args});
+        }
+        else {
+            $e->add_info({tag => 'DIAG', debug => 1, details => $msg});
+        }
+    }
+
+    $self->{+HUB}->send($e);
+    return $e;
+}
+
+sub fail_and_release {
+    my $self = shift;
+    my ($name, @diag) = @_;
+
+    my $e = bless(
+        {
+            trace => bless({%{$self->{+TRACE}}}, 'Test2::EventFacet::Trace'),
+            name  => $name,
+        },
+        "Test2::Event::Fail"
+    );
+
+    for my $msg (@diag) {
+        if (ref($msg) eq 'Test2::EventFacet::Info::Table') {
+            $e->add_info({tag => 'DIAG', debug => 1, $msg->info_args});
+        }
+        else {
+            $e->add_info({tag => 'DIAG', debug => 1, details => $msg});
+        }
+    }
+
+    $self->{+HUB}->send($e);
+    $self->release;
+    return 0;
+}
+
+sub ok {
+    my $self = shift;
+    my ($pass, $name, $on_fail) = @_;
+
+    my $hub = $self->{+HUB};
+
+    my $e = bless {
+        trace => bless( {%{$self->{+TRACE}}}, 'Test2::EventFacet::Trace'),
+        pass  => $pass,
+        name  => $name,
+    }, 'Test2::Event::Ok';
+    $e->init;
+
+    $hub->send($e);
+    return $e if $pass;
+
+    $self->failure_diag($e);
+
+    if ($on_fail && @$on_fail) {
+        $self->diag($_) for @$on_fail;
+    }
+
+    return $e;
+}
+
+sub failure_diag {
+    my $self = shift;
+    my ($e) = @_;
+
+    # Figure out the debug info, this is typically the file name and line
+    # number, but can also be a custom message. If no trace object is provided
+    # then we have nothing useful to display.
+    my $name  = $e->name;
+    my $trace = $e->trace;
+    my $debug = $trace ? $trace->debug : "[No trace info available]";
+
+    # Create the initial diagnostics. If the test has a name we put the debug
+    # info on a second line, this behavior is inherited from Test::Builder.
+    my $msg = defined($name)
+        ? qq[Failed test '$name'\n$debug.\n]
+        : qq[Failed test $debug.\n];
+
+    $self->diag($msg);
+}
+
+sub skip {
+    my $self = shift;
+    my ($name, $reason, @extra) = @_;
+    $self->send_event(
+        'Skip',
+        name => $name,
+        reason => $reason,
+        pass => 1,
+        @extra,
+    );
+}
+
+sub note {
+    my $self = shift;
+    my ($message) = @_;
+    $self->send_event('Note', message => $message);
+}
+
+sub diag {
+    my $self = shift;
+    my ($message) = @_;
+    my $hub = $self->{+HUB};
+    $self->send_event(
+        'Diag',
+        message => $message,
+    );
+}
+
+sub plan {
+    my ($self, $max, $directive, $reason) = @_;
+    $self->send_event('Plan', max => $max, directive => $directive, reason => $reason);
+}
+
+sub bail {
+    my ($self, $reason) = @_;
+    $self->send_event('Bail', reason => $reason);
+}
+
+sub _parse_event {
+    my $self = shift;
+    my $event = shift;
+
+    my $pkg;
+    if ($event =~ m/^\+(.*)/) {
+        $pkg = $1;
+    }
+    else {
+        $pkg = "Test2::Event::$event";
+    }
+
+    unless ($LOADED{$pkg}) {
+        my $file = pkg_to_file($pkg);
+        my ($ok, $err) = try { require $file };
+        $self->throw("Could not load event module '$pkg': $err")
+            unless $ok;
+
+        $LOADED{$pkg} = $pkg;
+    }
+
+    confess "'$pkg' is not a subclass of 'Test2::Event'"
+        unless $pkg->isa('Test2::Event');
+
+    $LOADED{$event} = $pkg;
+
+    return $pkg;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API::Context - Object to represent a testing context.
+
+=head1 DESCRIPTION
+
+The context object is the primary interface for authors of testing tools
+written with L<Test2>. The context object represents the context in
+which a test takes place (File and Line Number), and provides a quick way to
+generate events from that context. The context object also takes care of
+sending events to the correct L<Test2::Hub> instance.
+
+=head1 SYNOPSIS
+
+In general you will not be creating contexts directly. To obtain a context you
+should always use C<context()> which is exported by the L<Test2::API> module.
+
+    use Test2::API qw/context/;
+
+    sub my_ok {
+        my ($bool, $name) = @_;
+        my $ctx = context();
+
+        if ($bool) {
+            $ctx->pass($name);
+        }
+        else {
+            $ctx->fail($name);
+        }
+
+        $ctx->release; # You MUST do this!
+        return $bool;
+    }
+
+Context objects make it easy to wrap other tools that also use context. Once
+you grab a context, any tool you call before releasing your context will
+inherit it:
+
+    sub wrapper {
+        my ($bool, $name) = @_;
+        my $ctx = context();
+        $ctx->diag("wrapping my_ok");
+
+        my $out = my_ok($bool, $name);
+        $ctx->release; # You MUST do this!
+        return $out;
+    }
+
+=head1 CRITICAL DETAILS
+
+=over 4
+
+=item you MUST always use the context() sub from Test2::API
+
+Creating your own context via C<< Test2::API::Context->new() >> will almost never
+produce a desirable result. Use C<context()> which is exported by L<Test2::API>.
+
+There are a handful of cases where a tool author may want to create a new
+context by hand, which is why the C<new> method exists. Unless you really know
+what you are doing you should avoid this.
+
+=item You MUST always release the context when done with it
+
+Releasing the context tells the system you are done with it. This gives it a
+chance to run any necessary callbacks or cleanup tasks. If you forget to
+release the context it will try to detect the problem and warn you about it.
+
+=item You MUST NOT pass context objects around
+
+When you obtain a context object it is made specifically for your tool and any
+tools nested within. If you pass a context around you run the risk of polluting
+other tools with incorrect context information.
+
+If you are certain that you want a different tool to use the same context you
+may pass it a snapshot. C<< $ctx->snapshot >> will give you a shallow clone of
+the context that is safe to pass around or store.
+
+=item You MUST NOT store or cache a context for later
+
+As long as a context exists for a given hub, all tools that try to get a
+context will get the existing instance. If you try to store the context you
+will pollute other tools with incorrect context information.
+
+If you are certain that you want to save the context for later, you can use a
+snapshot. C<< $ctx->snapshot >> will give you a shallow clone of the context
+that is safe to pass around or store.
+
+C<context()> has some mechanisms to protect you if you do cause a context to
+persist beyond the scope in which it was obtained. In practice you should not
+rely on these protections, and they are fairly noisy with warnings.
+
+=item You SHOULD obtain your context as soon as possible in a given tool
+
+You never know what tools you call from within your own tool will need a
+context. Obtaining the context early ensures that nested tools can find the
+context you want them to find.
+
+=back
+
+=head1 METHODS
+
+=over 4
+
+=item $ctx->done_testing;
+
+Note that testing is finished. If no plan has been set this will generate a
+Plan event.
+
+=item $clone = $ctx->snapshot()
+
+This will return a shallow clone of the context. The shallow clone is safe to
+store for later.
+
+=item $ctx->release()
+
+This will release the context. This runs cleanup tasks, and several important
+hooks. It will also restore C<$!>, C<$?>, and C<$@> to what they were when the
+context was created.
+
+B<Note:> If a context is acquired more than once an internal refcount is kept.
+C<release()> decrements the ref count, none of the other actions of
+C<release()> will occur unless the refcount hits 0. This means only the last
+call to C<release()> will reset C<$?>, C<$!>, C<$@>,and run the cleanup tasks.
+
+=item $ctx->throw($message)
+
+This will throw an exception reporting to the file and line number of the
+context. This will also release the context for you.
+
+=item $ctx->alert($message)
+
+This will issue a warning from the file and line number of the context.
+
+=item $stack = $ctx->stack()
+
+This will return the L<Test2::API::Stack> instance the context used to find
+the current hub.
+
+=item $hub = $ctx->hub()
+
+This will return the L<Test2::Hub> instance the context recognizes as the
+current one to which all events should be sent.
+
+=item $dbg = $ctx->trace()
+
+This will return the L<Test2::EventFacet::Trace> instance used by the context.
+
+=item $ctx->do_in_context(\&code, @args);
+
+Sometimes you have a context that is not current, and you want things to use it
+as the current one. In these cases you can call
+C<< $ctx->do_in_context(sub { ... }) >>. The codeblock will be run, and
+anything inside of it that looks for a context will find the one on which the
+method was called.
+
+This B<DOES NOT> affect context on other hubs, only the hub used by the context
+will be affected.
+
+    my $ctx = ...;
+    $ctx->do_in_context(sub {
+        my $ctx = context(); # returns the $ctx the sub is called on
+    });
+
+B<Note:> The context will actually be cloned, the clone will be used instead of
+the original. This allows the thread id, process id, and error variables to be correct without
+modifying the original context.
+
+=item $ctx->restore_error_vars()
+
+This will set C<$!>, C<$?>, and C<$@> to what they were when the context was
+created. There is no localization or anything done here, calling this method
+will actually set these vars.
+
+=item $! = $ctx->errno()
+
+The (numeric) value of C<$!> when the context was created.
+
+=item $? = $ctx->child_error()
+
+The value of C<$?> when the context was created.
+
+=item $@ = $ctx->eval_error()
+
+The value of C<$@> when the context was created.
+
+=back
+
+=head2 EVENT PRODUCTION METHODS
+
+B<Which one do I use?>
+
+The C<pass*> and C<fail*> are optimal if they meet your situation, using one of
+them will always be the most optimal. That said they are optimal by eliminating
+many features.
+
+Method such as C<ok>, and C<note> are shortcuts for generating common 1-task
+events based on the old API, however they are forward compatible, and easy to
+use. If these meet your needs then go ahead and use them, but please check back
+often for alternatives that may be added.
+
+If you want to generate new style events, events that do many things at once,
+then you want the C<*ev2*> methods. These let you directly specify which facets
+you wish to use.
+
+=over 4
+
+=item $event = $ctx->pass()
+
+=item $event = $ctx->pass($name)
+
+This will send and return an L<Test2::Event::Pass> event. You may optionally
+provide a C<$name> for the assertion.
+
+The L<Test2::Event::Pass> is a specially crafted and optimized event, using
+this will help the performance of passing tests.
+
+=item $true = $ctx->pass_and_release()
+
+=item $true = $ctx->pass_and_release($name)
+
+This is a combination of C<pass()> and C<release()>. You can use this if you do
+not plan to do anything with the context after sending the event. This helps
+write more clear and compact code.
+
+    sub shorthand {
+        my ($bool, $name) = @_;
+        my $ctx = context();
+        return $ctx->pass_and_release($name) if $bool;
+
+        ... Handle a failure ...
+    }
+
+    sub longform {
+        my ($bool, $name) = @_;
+        my $ctx = context();
+
+        if ($bool) {
+            $ctx->pass($name);
+            $ctx->release;
+            return 1;
+        }
+
+        ... Handle a failure ...
+    }
+
+=item my $event = $ctx->fail()
+
+=item my $event = $ctx->fail($name)
+
+=item my $event = $ctx->fail($name, @diagnostics)
+
+This lets you send an L<Test2::Event::Fail> event. You may optionally provide a
+C<$name> and C<@diagnostics> messages.
+
+Diagnostics messages can be simple strings, data structures, or instances of
+L<Test2::EventFacet::Info::Table> (which are converted inline into the
+L<Test2::EventFacet::Info> structure).
+
+=item my $false = $ctx->fail_and_release()
+
+=item my $false = $ctx->fail_and_release($name)
+
+=item my $false = $ctx->fail_and_release($name, @diagnostics)
+
+This is a combination of C<fail()> and C<release()>. This can be used to write
+clearer and shorter code.
+
+    sub shorthand {
+        my ($bool, $name) = @_;
+        my $ctx = context();
+        return $ctx->fail_and_release($name) unless $bool;
+
+        ... Handle a success ...
+    }
+
+    sub longform {
+        my ($bool, $name) = @_;
+        my $ctx = context();
+
+        unless ($bool) {
+            $ctx->pass($name);
+            $ctx->release;
+            return 1;
+        }
+
+        ... Handle a success ...
+    }
+
+
+=item $event = $ctx->ok($bool, $name)
+
+=item $event = $ctx->ok($bool, $name, \@on_fail)
+
+B<NOTE:> Use of this method is discouraged in favor of C<pass()> and C<fail()>
+which produce L<Test2::Event::Pass> and L<Test2::Event::Fail> events. These
+newer event types are faster and less crufty.
+
+This will create an L<Test2::Event::Ok> object for you. If C<$bool> is false
+then an L<Test2::Event::Diag> event will be sent as well with details about the
+failure. If you do not want automatic diagnostics you should use the
+C<send_event()> method directly.
+
+The third argument C<\@on_fail>) is an optional set of diagnostics to be sent in
+the event of a test failure. Unlike with C<fail()> these diagnostics must be
+plain strings, data structures are not supported.
+
+=item $event = $ctx->note($message)
+
+Send an L<Test2::Event::Note>. This event prints a message to STDOUT.
+
+=item $event = $ctx->diag($message)
+
+Send an L<Test2::Event::Diag>. This event prints a message to STDERR.
+
+=item $event = $ctx->plan($max)
+
+=item $event = $ctx->plan(0, 'SKIP', $reason)
+
+This can be used to send an L<Test2::Event::Plan> event. This event
+usually takes either a number of tests you expect to run. Optionally you can
+set the expected count to 0 and give the 'SKIP' directive with a reason to
+cause all tests to be skipped.
+
+=item $event = $ctx->skip($name, $reason);
+
+Send an L<Test2::Event::Skip> event.
+
+=item $event = $ctx->bail($reason)
+
+This sends an L<Test2::Event::Bail> event. This event will completely
+terminate all testing.
+
+=item $event = $ctx->send_ev2(%facets)
+
+This lets you build and send a V2 event directly from facets. The event is
+returned after it is sent.
+
+This example sends a single assertion, a note (comment for stdout in
+Test::Builder talk) and sets the plan to 1.
+
+    my $event = $ctx->send_event(
+        plan   => {count => 1},
+        assert => {pass  => 1, details => "A passing assert"},
+        info => [{tag => 'NOTE', details => "This is a note"}],
+    );
+
+=item $event = $ctx->build_e2(%facets)
+
+This is the same as C<send_ev2()>, except it builds and returns the event
+without sending it.
+
+=item $event = $ctx->send_ev2_and_release($Type, %parameters)
+
+This is a combination of C<send_ev2()> and C<release()>.
+
+    sub shorthand {
+        my $ctx = context();
+        return $ctx->send_ev2_and_release(assert => {pass => 1, details => 'foo'});
+    }
+
+    sub longform {
+        my $ctx = context();
+        my $event = $ctx->send_ev2(assert => {pass => 1, details => 'foo'});
+        $ctx->release;
+        return $event;
+    }
+
+=item $event = $ctx->send_event($Type, %parameters)
+
+B<It is better to use send_ev2() in new code.>
+
+This lets you build and send an event of any type. The C<$Type> argument should
+be the event package name with C<Test2::Event::> left off, or a fully
+qualified package name prefixed with a '+'. The event is returned after it is
+sent.
+
+    my $event = $ctx->send_event('Ok', ...);
+
+or
+
+    my $event = $ctx->send_event('+Test2::Event::Ok', ...);
+
+=item $event = $ctx->build_event($Type, %parameters)
+
+B<It is better to use build_ev2() in new code.>
+
+This is the same as C<send_event()>, except it builds and returns the event
+without sending it.
+
+=item $event = $ctx->send_event_and_release($Type, %parameters)
+
+B<It is better to use send_ev2_and_release() in new code.>
+
+This is a combination of C<send_event()> and C<release()>.
+
+    sub shorthand {
+        my $ctx = context();
+        return $ctx->send_event_and_release(Pass => { name => 'foo' });
+    }
+
+    sub longform {
+        my $ctx = context();
+        my $event = $ctx->send_event(Pass => { name => 'foo' });
+        $ctx->release;
+        return $event;
+    }
+
+=back
+
+=head1 HOOKS
+
+There are 2 types of hooks, init hooks, and release hooks. As the names
+suggest, these hooks are triggered when contexts are created or released.
+
+=head2 INIT HOOKS
+
+These are called whenever a context is initialized. That means when a new
+instance is created. These hooks are B<NOT> called every time something
+requests a context, just when a new one is created.
+
+=head3 GLOBAL
+
+This is how you add a global init callback. Global callbacks happen for every
+context for any hub or stack.
+
+    Test2::API::test2_add_callback_context_init(sub {
+        my $ctx = shift;
+        ...
+    });
+
+=head3 PER HUB
+
+This is how you add an init callback for all contexts created for a given hub.
+These callbacks will not run for other hubs.
+
+    $hub->add_context_init(sub {
+        my $ctx = shift;
+        ...
+    });
+
+=head3 PER CONTEXT
+
+This is how you specify an init hook that will only run if your call to
+C<context()> generates a new context. The callback will be ignored if
+C<context()> is returning an existing context.
+
+    my $ctx = context(on_init => sub {
+        my $ctx = shift;
+        ...
+    });
+
+=head2 RELEASE HOOKS
+
+These are called whenever a context is released. That means when the last
+reference to the instance is about to be destroyed. These hooks are B<NOT>
+called every time C<< $ctx->release >> is called.
+
+=head3 GLOBAL
+
+This is how you add a global release callback. Global callbacks happen for every
+context for any hub or stack.
+
+    Test2::API::test2_add_callback_context_release(sub {
+        my $ctx = shift;
+        ...
+    });
+
+=head3 PER HUB
+
+This is how you add a release callback for all contexts created for a given
+hub. These callbacks will not run for other hubs.
+
+    $hub->add_context_release(sub {
+        my $ctx = shift;
+        ...
+    });
+
+=head3 PER CONTEXT
+
+This is how you add release callbacks directly to a context. The callback will
+B<ALWAYS> be added to the context that gets returned, it does not matter if a
+new one is generated, or if an existing one is returned.
+
+    my $ctx = context(on_release => sub {
+        my $ctx = shift;
+        ...
+    });
+
+=head1 THIRD PARTY META-DATA
+
+This object consumes L<Test2::Util::ExternalMeta> which provides a consistent
+way for you to attach meta-data to instances of this class. This is useful for
+tools, plugins, and other extensions.
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=item Kent Fredric E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/API/Instance.pm

@@ -0,0 +1,822 @@
+package Test2::API::Instance;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+our @CARP_NOT = qw/Test2::API Test2::API::Instance Test2::IPC::Driver Test2::Formatter/;
+use Carp qw/confess carp/;
+use Scalar::Util qw/reftype/;
+
+use Test2::Util qw/get_tid USE_THREADS CAN_FORK pkg_to_file try CAN_SIGSYS/;
+
+use Test2::EventFacet::Trace();
+use Test2::API::Stack();
+
+use Test2::Util::HashBase qw{
+    _pid _tid
+    no_wait
+    finalized loaded
+    ipc stack formatter
+    contexts
+
+    add_uuid_via
+
+    -preload
+
+    ipc_disabled
+    ipc_polling
+    ipc_drivers
+    ipc_timeout
+    formatters
+
+    exit_callbacks
+    post_load_callbacks
+    context_acquire_callbacks
+    context_init_callbacks
+    context_release_callbacks
+    pre_subtest_callbacks
+};
+
+sub DEFAULT_IPC_TIMEOUT() { 30 }
+
+sub pid { $_[0]->{+_PID} }
+sub tid { $_[0]->{+_TID} }
+
+# Wrap around the getters that should call _finalize.
+BEGIN {
+    for my $finalizer (IPC, FORMATTER) {
+        my $orig = __PACKAGE__->can($finalizer);
+        my $new  = sub {
+            my $self = shift;
+            $self->_finalize unless $self->{+FINALIZED};
+            $self->$orig;
+        };
+
+        no strict 'refs';
+        no warnings 'redefine';
+        *{$finalizer} = $new;
+    }
+}
+
+sub has_ipc { !!$_[0]->{+IPC} }
+
+sub import {
+    my $class = shift;
+    return unless @_;
+    my ($ref) = @_;
+    $$ref = $class->new;
+}
+
+sub init { $_[0]->reset }
+
+sub start_preload {
+    my $self = shift;
+
+    confess "preload cannot be started, Test2::API has already been initialized"
+        if $self->{+FINALIZED} || $self->{+LOADED};
+
+    return $self->{+PRELOAD} = 1;
+}
+
+sub stop_preload {
+    my $self = shift;
+
+    return 0 unless $self->{+PRELOAD};
+    $self->{+PRELOAD} = 0;
+
+    $self->post_preload_reset();
+
+    return 1;
+}
+
+sub post_preload_reset {
+    my $self = shift;
+
+    delete $self->{+_PID};
+    delete $self->{+_TID};
+
+    $self->{+ADD_UUID_VIA} = undef unless exists $self->{+ADD_UUID_VIA};
+
+    $self->{+CONTEXTS} = {};
+
+    $self->{+FORMATTERS} = [];
+
+    $self->{+FINALIZED} = undef;
+    $self->{+IPC}       = undef;
+    $self->{+IPC_DISABLED} = $ENV{T2_NO_IPC} ? 1 : 0;
+
+    $self->{+IPC_TIMEOUT} = DEFAULT_IPC_TIMEOUT() unless defined $self->{+IPC_TIMEOUT};
+
+    $self->{+LOADED} = 0;
+
+    $self->{+STACK} ||= Test2::API::Stack->new;
+}
+
+sub reset {
+    my $self = shift;
+
+    delete $self->{+_PID};
+    delete $self->{+_TID};
+
+    $self->{+ADD_UUID_VIA} = undef;
+
+    $self->{+CONTEXTS} = {};
+
+    $self->{+IPC_DRIVERS} = [];
+    $self->{+IPC_POLLING} = undef;
+
+    $self->{+FORMATTERS} = [];
+    $self->{+FORMATTER}  = undef;
+
+    $self->{+FINALIZED}    = undef;
+    $self->{+IPC}          = undef;
+    $self->{+IPC_DISABLED} = $ENV{T2_NO_IPC} ? 1 : 0;
+
+    $self->{+IPC_TIMEOUT} = DEFAULT_IPC_TIMEOUT() unless defined $self->{+IPC_TIMEOUT};
+
+    $self->{+NO_WAIT} = 0;
+    $self->{+LOADED}  = 0;
+
+    $self->{+EXIT_CALLBACKS}            = [];
+    $self->{+POST_LOAD_CALLBACKS}       = [];
+    $self->{+CONTEXT_ACQUIRE_CALLBACKS} = [];
+    $self->{+CONTEXT_INIT_CALLBACKS}    = [];
+    $self->{+CONTEXT_RELEASE_CALLBACKS} = [];
+    $self->{+PRE_SUBTEST_CALLBACKS}     = [];
+
+    $self->{+STACK} = Test2::API::Stack->new;
+}
+
+sub _finalize {
+    my $self = shift;
+    my ($caller) = @_;
+    $caller ||= [caller(1)];
+
+    confess "Attempt to initialize Test2::API during preload"
+        if $self->{+PRELOAD};
+
+    $self->{+FINALIZED} = $caller;
+
+    $self->{+_PID} = $$        unless defined $self->{+_PID};
+    $self->{+_TID} = get_tid() unless defined $self->{+_TID};
+
+    unless ($self->{+FORMATTER}) {
+        my ($formatter, $source);
+        if ($ENV{T2_FORMATTER}) {
+            $source = "set by the 'T2_FORMATTER' environment variable";
+
+            if ($ENV{T2_FORMATTER} =~ m/^(\+)?(.*)$/) {
+                $formatter = $1 ? $2 : "Test2::Formatter::$2"
+            }
+            else {
+                $formatter = '';
+            }
+        }
+        elsif (@{$self->{+FORMATTERS}}) {
+            ($formatter) = @{$self->{+FORMATTERS}};
+            $source = "Most recently added";
+        }
+        else {
+            $formatter = 'Test2::Formatter::TAP';
+            $source    = 'default formatter';
+        }
+
+        unless (ref($formatter) || $formatter->can('write')) {
+            my $file = pkg_to_file($formatter);
+            my ($ok, $err) = try { require $file };
+            unless ($ok) {
+                my $line   = "* COULD NOT LOAD FORMATTER '$formatter' ($source) *";
+                my $border = '*' x length($line);
+                die "\n\n  $border\n  $line\n  $border\n\n$err";
+            }
+        }
+
+        $self->{+FORMATTER} = $formatter;
+    }
+
+    # Turn on IPC if threads are on, drivers are registered, or the Test2::IPC
+    # module is loaded.
+    return if $self->{+IPC_DISABLED};
+    return unless USE_THREADS || $INC{'Test2/IPC.pm'} || @{$self->{+IPC_DRIVERS}};
+
+    # Turn on polling by default, people expect it.
+    $self->enable_ipc_polling;
+
+    unless (@{$self->{+IPC_DRIVERS}}) {
+        my ($ok, $error) = try { require Test2::IPC::Driver::Files };
+        die $error unless $ok;
+        push @{$self->{+IPC_DRIVERS}} => 'Test2::IPC::Driver::Files';
+    }
+
+    for my $driver (@{$self->{+IPC_DRIVERS}}) {
+        next unless $driver->can('is_viable') && $driver->is_viable;
+        $self->{+IPC} = $driver->new or next;
+        return;
+    }
+
+    die "IPC has been requested, but no viable drivers were found. Aborting...\n";
+}
+
+sub formatter_set { $_[0]->{+FORMATTER} ? 1 : 0 }
+
+sub add_formatter {
+    my $self = shift;
+    my ($formatter) = @_;
+    unshift @{$self->{+FORMATTERS}} => $formatter;
+
+    return unless $self->{+FINALIZED};
+
+    # Why is the @CARP_NOT entry not enough?
+    local %Carp::Internal = %Carp::Internal;
+    $Carp::Internal{'Test2::Formatter'} = 1;
+
+    carp "Formatter $formatter loaded too late to be used as the global formatter";
+}
+
+sub add_context_acquire_callback {
+    my $self =  shift;
+    my ($code) = @_;
+
+    my $rtype = reftype($code) || "";
+
+    confess "Context-acquire callbacks must be coderefs"
+        unless $code && $rtype eq 'CODE';
+
+    push @{$self->{+CONTEXT_ACQUIRE_CALLBACKS}} => $code;
+}
+
+sub add_context_init_callback {
+    my $self =  shift;
+    my ($code) = @_;
+
+    my $rtype = reftype($code) || "";
+
+    confess "Context-init callbacks must be coderefs"
+        unless $code && $rtype eq 'CODE';
+
+    push @{$self->{+CONTEXT_INIT_CALLBACKS}} => $code;
+}
+
+sub add_context_release_callback {
+    my $self =  shift;
+    my ($code) = @_;
+
+    my $rtype = reftype($code) || "";
+
+    confess "Context-release callbacks must be coderefs"
+        unless $code && $rtype eq 'CODE';
+
+    push @{$self->{+CONTEXT_RELEASE_CALLBACKS}} => $code;
+}
+
+sub add_post_load_callback {
+    my $self = shift;
+    my ($code) = @_;
+
+    my $rtype = reftype($code) || "";
+
+    confess "Post-load callbacks must be coderefs"
+        unless $code && $rtype eq 'CODE';
+
+    push @{$self->{+POST_LOAD_CALLBACKS}} => $code;
+    $code->() if $self->{+LOADED};
+}
+
+sub add_pre_subtest_callback {
+    my $self =  shift;
+    my ($code) = @_;
+
+    my $rtype = reftype($code) || "";
+
+    confess "Pre-subtest callbacks must be coderefs"
+        unless $code && $rtype eq 'CODE';
+
+    push @{$self->{+PRE_SUBTEST_CALLBACKS}} => $code;
+}
+
+sub load {
+    my $self = shift;
+    unless ($self->{+LOADED}) {
+        confess "Attempt to initialize Test2::API during preload"
+            if $self->{+PRELOAD};
+
+        $self->{+_PID} = $$        unless defined $self->{+_PID};
+        $self->{+_TID} = get_tid() unless defined $self->{+_TID};
+
+        # This is for https://github.com/Test-More/test-more/issues/16
+        # and https://rt.perl.org/Public/Bug/Display.html?id=127774
+        # END blocks run in reverse order. This insures the END block is loaded
+        # as late as possible. It will not solve all cases, but it helps.
+        eval "END { Test2::API::test2_set_is_end() }; 1" or die $@;
+
+        $self->{+LOADED} = 1;
+        $_->() for @{$self->{+POST_LOAD_CALLBACKS}};
+    }
+    return $self->{+LOADED};
+}
+
+sub add_exit_callback {
+    my $self = shift;
+    my ($code) = @_;
+    my $rtype = reftype($code) || "";
+
+    confess "End callbacks must be coderefs"
+        unless $code && $rtype eq 'CODE';
+
+    push @{$self->{+EXIT_CALLBACKS}} => $code;
+}
+
+sub ipc_disable {
+    my $self = shift;
+
+    confess "Attempt to disable IPC after it has been initialized"
+        if $self->{+IPC};
+
+    $self->{+IPC_DISABLED} = 1;
+}
+
+sub add_ipc_driver {
+    my $self = shift;
+    my ($driver) = @_;
+    unshift @{$self->{+IPC_DRIVERS}} => $driver;
+
+    return unless $self->{+FINALIZED};
+
+    # Why is the @CARP_NOT entry not enough?
+    local %Carp::Internal = %Carp::Internal;
+    $Carp::Internal{'Test2::IPC::Driver'} = 1;
+
+    carp "IPC driver $driver loaded too late to be used as the global ipc driver";
+}
+
+sub enable_ipc_polling {
+    my $self = shift;
+
+    $self->{+_PID} = $$        unless defined $self->{+_PID};
+    $self->{+_TID} = get_tid() unless defined $self->{+_TID};
+
+    $self->add_context_init_callback(
+        # This is called every time a context is created, it needs to be fast.
+        # $_[0] is a context object
+        sub {
+            return unless $self->{+IPC_POLLING};
+            return unless $self->{+IPC};
+            return unless $self->{+IPC}->pending();
+            return $_[0]->{hub}->cull;
+        }
+    ) unless defined $self->ipc_polling;
+
+    $self->set_ipc_polling(1);
+}
+
+sub get_ipc_pending {
+    my $self = shift;
+    return -1 unless $self->{+IPC};
+    $self->{+IPC}->pending();
+}
+
+sub _check_pid {
+    my $self = shift;
+    my ($pid) = @_;
+    return kill(0, $pid);
+}
+
+sub set_ipc_pending {
+    my $self = shift;
+    return unless $self->{+IPC};
+    my ($val) = @_;
+
+    confess "value is required for set_ipc_pending"
+        unless $val;
+
+    $self->{+IPC}->set_pending($val);
+}
+
+sub disable_ipc_polling {
+    my $self = shift;
+    return unless defined $self->{+IPC_POLLING};
+    $self->{+IPC_POLLING} = 0;
+}
+
+sub _ipc_wait {
+    my ($timeout) = @_;
+    my $fail = 0;
+
+    $timeout = DEFAULT_IPC_TIMEOUT() unless defined $timeout;
+
+    my $ok = eval {
+        if (CAN_FORK) {
+            local $SIG{ALRM} = sub { die "Timeout waiting on child processes" };
+            alarm $timeout;
+
+            while (1) {
+                my $pid = CORE::wait();
+                my $err = $?;
+                last if $pid == -1;
+                next unless $err;
+                $fail++;
+
+                my $sig = $err & 127;
+                my $exit = $err >> 8;
+                warn "Process $pid did not exit cleanly (wstat: $err, exit: $exit, sig: $sig)\n";
+            }
+
+            alarm 0;
+        }
+
+        if (USE_THREADS) {
+            my $start = time;
+
+            while (1) {
+                last unless threads->list();
+                die "Timeout waiting on child thread" if time - $start >= $timeout;
+                sleep 1;
+                for my $t (threads->list) {
+                    # threads older than 1.34 do not have this :-(
+                    next if $t->can('is_joinable') && !$t->is_joinable;
+                    $t->join;
+                    # In older threads we cannot check if a thread had an error unless
+                    # we control it and its return.
+                    my $err = $t->can('error') ? $t->error : undef;
+                    next unless $err;
+                    my $tid = $t->tid();
+                    $fail++;
+                    chomp($err);
+                    warn "Thread $tid did not end cleanly: $err\n";
+                }
+            }
+        }
+
+        1;
+    };
+    my $error = $@;
+
+    return 0 if $ok && !$fail;
+    warn $error unless $ok;
+    return 255;
+}
+
+sub set_exit {
+    my $self = shift;
+
+    return if $self->{+PRELOAD};
+
+    my $exit     = $?;
+    my $new_exit = $exit;
+
+    if ($INC{'Test/Builder.pm'} && $Test::Builder::VERSION ne $Test2::API::VERSION) {
+        print STDERR <<"        EOT";
+
+********************************************************************************
+*                                                                              *
+*            Test::Builder -- Test2::API version mismatch detected             *
+*                                                                              *
+********************************************************************************
+   Test2::API Version: $Test2::API::VERSION
+Test::Builder Version: $Test::Builder::VERSION
+
+This is not a supported configuration, you will have problems.
+
+        EOT
+    }
+
+    for my $ctx (values %{$self->{+CONTEXTS}}) {
+        next unless $ctx;
+
+        next if $ctx->_aborted && ${$ctx->_aborted};
+
+        # Only worry about contexts in this PID
+        my $trace = $ctx->trace || next;
+        next unless $trace->pid && $trace->pid == $$;
+
+        # Do not worry about contexts that have no hub
+        my $hub = $ctx->hub  || next;
+
+        # Do not worry if the state came to a sudden end.
+        next if $hub->bailed_out;
+        next if defined $hub->skip_reason;
+
+        # now we worry
+        $trace->alert("context object was never released! This means a testing tool is behaving very badly");
+
+        $exit     = 255;
+        $new_exit = 255;
+    }
+
+    if (!defined($self->{+_PID}) or !defined($self->{+_TID}) or $self->{+_PID} != $$ or $self->{+_TID} != get_tid()) {
+        $? = $exit;
+        return;
+    }
+
+    my @hubs = $self->{+STACK} ? $self->{+STACK}->all : ();
+
+    if (@hubs and $self->{+IPC} and !$self->{+NO_WAIT}) {
+        local $?;
+        my %seen;
+        for my $hub (reverse @hubs) {
+            my $ipc = $hub->ipc or next;
+            next if $seen{$ipc}++;
+            $ipc->waiting();
+        }
+
+        my $ipc_exit = _ipc_wait($self->{+IPC_TIMEOUT});
+        $new_exit ||= $ipc_exit;
+    }
+
+    # None of this is necessary if we never got a root hub
+    if(my $root = shift @hubs) {
+        my $trace = Test2::EventFacet::Trace->new(
+            frame  => [__PACKAGE__, __FILE__, 0, __PACKAGE__ . '::END'],
+            detail => __PACKAGE__ . ' END Block finalization',
+        );
+        my $ctx = Test2::API::Context->new(
+            trace => $trace,
+            hub   => $root,
+        );
+
+        if (@hubs) {
+            $ctx->diag("Test ended with extra hubs on the stack!");
+            $new_exit  = 255;
+        }
+
+        unless ($root->no_ending) {
+            local $?;
+            $root->finalize($trace) unless $root->ended;
+            $_->($ctx, $exit, \$new_exit) for @{$self->{+EXIT_CALLBACKS}};
+            $new_exit ||= $root->failed;
+            $new_exit ||= 255 unless $root->is_passing;
+        }
+    }
+
+    $new_exit = 255 if $new_exit > 255;
+
+    if ($new_exit && eval { require Test2::API::Breakage; 1 }) {
+        my @warn = Test2::API::Breakage->report();
+
+        if (@warn) {
+            print STDERR "\nYou have loaded versions of test modules known to have problems with Test2.\nThis could explain some test failures.\n";
+            print STDERR "$_\n" for @warn;
+            print STDERR "\n";
+        }
+    }
+
+    $? = $new_exit;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API::Instance - Object used by Test2::API under the hood
+
+=head1 DESCRIPTION
+
+This object encapsulates the global shared state tracked by
+L<Test2>. A single global instance of this package is stored (and
+obscured) by the L<Test2::API> package.
+
+There is no reason to directly use this package. This package is documented for
+completeness. This package can change, or go away completely at any time.
+Directly using, or monkeypatching this package is not supported in any way
+shape or form.
+
+=head1 SYNOPSIS
+
+    use Test2::API::Instance;
+
+    my $obj = Test2::API::Instance->new;
+
+=over 4
+
+=item $pid = $obj->pid
+
+PID of this instance.
+
+=item $obj->tid
+
+Thread ID of this instance.
+
+=item $obj->reset()
+
+Reset the object to defaults.
+
+=item $obj->load()
+
+Set the internal state to loaded, and run and stored post-load callbacks.
+
+=item $bool = $obj->loaded
+
+Check if the state is set to loaded.
+
+=item $arrayref = $obj->post_load_callbacks
+
+Get the post-load callbacks.
+
+=item $obj->add_post_load_callback(sub { ... })
+
+Add a post-load callback. If C<load()> has already been called then the callback will
+be immediately executed. If C<load()> has not been called then the callback will be
+stored and executed later when C<load()> is called.
+
+=item $hashref = $obj->contexts()
+
+Get a hashref of all active contexts keyed by hub id.
+
+=item $arrayref = $obj->context_acquire_callbacks
+
+Get all context acquire callbacks.
+
+=item $arrayref = $obj->context_init_callbacks
+
+Get all context init callbacks.
+
+=item $arrayref = $obj->context_release_callbacks
+
+Get all context release callbacks.
+
+=item $arrayref = $obj->pre_subtest_callbacks
+
+Get all pre-subtest callbacks.
+
+=item $obj->add_context_init_callback(sub { ... })
+
+Add a context init callback. Subs are called every time a context is created. Subs
+get the newly created context as their only argument.
+
+=item $obj->add_context_release_callback(sub { ... })
+
+Add a context release callback. Subs are called every time a context is released. Subs
+get the released context as their only argument. These callbacks should not
+call release on the context.
+
+=item $obj->add_pre_subtest_callback(sub { ... })
+
+Add a pre-subtest callback. Subs are called every time a subtest is
+going to be run. Subs get the subtest name, coderef, and any
+arguments.
+
+=item $obj->set_exit()
+
+This is intended to be called in an C<END { ... }> block. This will look at
+test state and set $?. This will also call any end callbacks, and wait on child
+processes/threads.
+
+=item $obj->set_ipc_pending($val)
+
+Tell other processes and threads there is a pending event. C<$val> should be a
+unique value no other thread/process will generate.
+
+B<Note:> This will also make the current process see a pending event.
+
+=item $pending = $obj->get_ipc_pending()
+
+This returns -1 if it is not possible to know.
+
+This returns 0 if there are no pending events.
+
+This returns 1 if there are pending events.
+
+=item $timeout = $obj->ipc_timeout;
+
+=item $obj->set_ipc_timeout($timeout);
+
+How long to wait for child processes and threads before aborting.
+
+=item $drivers = $obj->ipc_drivers
+
+Get the list of IPC drivers.
+
+=item $obj->add_ipc_driver($DRIVER_CLASS)
+
+Add an IPC driver to the list. The most recently added IPC driver will become
+the global one during initialization. If a driver is added after initialization
+has occurred a warning will be generated:
+
+    "IPC driver $driver loaded too late to be used as the global ipc driver"
+
+=item $bool = $obj->ipc_polling
+
+Check if polling is enabled.
+
+=item $obj->enable_ipc_polling
+
+Turn on polling. This will cull events from other processes and threads every
+time a context is created.
+
+=item $obj->disable_ipc_polling
+
+Turn off IPC polling.
+
+=item $bool = $obj->no_wait
+
+=item $bool = $obj->set_no_wait($bool)
+
+Get/Set no_wait. This option is used to turn off process/thread waiting at exit.
+
+=item $arrayref = $obj->exit_callbacks
+
+Get the exit callbacks.
+
+=item $obj->add_exit_callback(sub { ... })
+
+Add an exit callback. This callback will be called by C<set_exit()>.
+
+=item $bool = $obj->finalized
+
+Check if the object is finalized. Finalization happens when either C<ipc()>,
+C<stack()>, or C<format()> are called on the object. Once finalization happens
+these fields are considered unchangeable (not enforced here, enforced by
+L<Test2>).
+
+=item $ipc = $obj->ipc
+
+Get the one true IPC instance.
+
+=item $obj->ipc_disable
+
+Turn IPC off
+
+=item $bool = $obj->ipc_disabled
+
+Check if IPC is disabled
+
+=item $stack = $obj->stack
+
+Get the one true hub stack.
+
+=item $formatter = $obj->formatter
+
+Get the global formatter. By default this is the C<'Test2::Formatter::TAP'>
+package. This could be any package that implements the C<write()> method. This
+can also be an instantiated object.
+
+=item $bool = $obj->formatter_set()
+
+Check if a formatter has been set.
+
+=item $obj->add_formatter($class)
+
+=item $obj->add_formatter($obj)
+
+Add a formatter. The most recently added formatter will become the global one
+during initialization. If a formatter is added after initialization has occurred
+a warning will be generated:
+
+    "Formatter $formatter loaded too late to be used as the global formatter"
+
+=item $obj->set_add_uuid_via(sub { ... })
+
+=item $sub = $obj->add_uuid_via()
+
+This allows you to provide a UUID generator. If provided UUIDs will be attached
+to all events, hubs, and contexts. This is useful for storing, tracking, and
+linking these objects.
+
+The sub you provide should always return a unique identifier. Most things will
+expect a proper UUID string, however nothing in Test2::API enforces this.
+
+The sub will receive exactly 1 argument, the type of thing being tagged
+'context', 'hub', or 'event'. In the future additional things may be tagged, in
+which case new strings will be passed in. These are purely informative, you can
+(and usually should) ignore them.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/API/Stack.pm

@@ -0,0 +1,220 @@
+package Test2::API::Stack;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+
+use Test2::Hub();
+
+use Carp qw/confess/;
+
+sub new {
+    my $class = shift;
+    return bless [], $class;
+}
+
+sub new_hub {
+    my $self = shift;
+    my %params = @_;
+
+    my $class = delete $params{class} || 'Test2::Hub';
+
+    my $hub = $class->new(%params);
+
+    if (@$self) {
+        $hub->inherit($self->[-1], %params);
+    }
+    else {
+        require Test2::API;
+        $hub->format(Test2::API::test2_formatter()->new_root)
+            unless $hub->format || exists($params{formatter});
+
+        my $ipc = Test2::API::test2_ipc();
+        if ($ipc && !$hub->ipc && !exists($params{ipc})) {
+            $hub->set_ipc($ipc);
+            $ipc->add_hub($hub->hid);
+        }
+    }
+
+    push @$self => $hub;
+
+    $hub;
+}
+
+sub top {
+    my $self = shift;
+    return $self->new_hub unless @$self;
+    return $self->[-1];
+}
+
+sub peek {
+    my $self = shift;
+    return @$self ? $self->[-1] : undef;
+}
+
+sub cull {
+    my $self = shift;
+    $_->cull for reverse @$self;
+}
+
+sub all {
+    my $self = shift;
+    return @$self;
+}
+
+sub clear {
+    my $self = shift;
+    @$self = ();
+}
+
+# Do these last without keywords in order to prevent them from getting used
+# when we want the real push/pop.
+
+{
+    no warnings 'once';
+
+    *push = sub {
+        my $self = shift;
+        my ($hub) = @_;
+        $hub->inherit($self->[-1]) if @$self;
+        push @$self => $hub;
+    };
+
+    *pop = sub {
+        my $self = shift;
+        my ($hub) = @_;
+        confess "No hubs on the stack"
+            unless @$self;
+        confess "You cannot pop the root hub"
+            if 1 == @$self;
+        confess "Hub stack mismatch, attempted to pop incorrect hub"
+            unless $self->[-1] == $hub;
+        pop @$self;
+    };
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API::Stack - Object to manage a stack of L<Test2::Hub>
+instances.
+
+=head1 ***INTERNALS NOTE***
+
+B<The internals of this package are subject to change at any time!> The public
+methods provided will not change in backwards incompatible ways, but the
+underlying implementation details might. B<Do not break encapsulation here!>
+
+=head1 DESCRIPTION
+
+This module is used to represent and manage a stack of L<Test2::Hub>
+objects. Hubs are usually in a stack so that you can push a new hub into place
+that can intercept and handle events differently than the primary hub.
+
+=head1 SYNOPSIS
+
+    my $stack = Test2::API::Stack->new;
+    my $hub = $stack->top;
+
+=head1 METHODS
+
+=over 4
+
+=item $stack = Test2::API::Stack->new()
+
+This will create a new empty stack instance. All arguments are ignored.
+
+=item $hub = $stack->new_hub()
+
+=item $hub = $stack->new_hub(%params)
+
+=item $hub = $stack->new_hub(%params, class => $class)
+
+This will generate a new hub and push it to the top of the stack. Optionally
+you can provide arguments that will be passed into the constructor for the
+L<Test2::Hub> object.
+
+If you specify the C<< 'class' => $class >> argument, the new hub will be an
+instance of the specified class.
+
+Unless your parameters specify C<'formatter'> or C<'ipc'> arguments, the
+formatter and IPC instance will be inherited from the current top hub. You can
+set the parameters to C<undef> to avoid having a formatter or IPC instance.
+
+If there is no top hub, and you do not ask to leave IPC and formatter undef,
+then a new formatter will be created, and the IPC instance from
+L<Test2::API> will be used.
+
+=item $hub = $stack->top()
+
+This will return the top hub from the stack. If there is no top hub yet this
+will create it.
+
+=item $hub = $stack->peek()
+
+This will return the top hub from the stack. If there is no top hub yet this
+will return undef.
+
+=item $stack->cull
+
+This will call C<< $hub->cull >> on all hubs in the stack.
+
+=item @hubs = $stack->all
+
+This will return all the hubs in the stack as a list.
+
+=item $stack->clear
+
+This will completely remove all hubs from the stack. Normally you do not want
+to do this, but there are a few valid reasons for it.
+
+=item $stack->push($hub)
+
+This will push the new hub onto the stack.
+
+=item $stack->pop($hub)
+
+This will pop a hub from the stack, if the hub at the top of the stack does not
+match the hub you expect (passed in as an argument) it will throw an exception.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Event/Diag.pm

@@ -0,0 +1,99 @@
+package Test2::Event::Diag;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+
+BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) }
+use Test2::Util::HashBase qw/message/;
+
+sub init {
+    $_[0]->{+MESSAGE} = 'undef' unless defined $_[0]->{+MESSAGE};
+}
+
+sub summary { $_[0]->{+MESSAGE} }
+
+sub diagnostics { 1 }
+
+sub facet_data {
+    my $self = shift;
+
+    my $out = $self->common_facet_data;
+
+    $out->{info} = [
+        {
+            tag     => 'DIAG',
+            debug   => 1,
+            details => $self->{+MESSAGE},
+        }
+    ];
+
+    return $out;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Event::Diag - Diag event type
+
+=head1 DESCRIPTION
+
+Diagnostics messages, typically rendered to STDERR.
+
+=head1 SYNOPSIS
+
+    use Test2::API qw/context/;
+    use Test2::Event::Diag;
+
+    my $ctx = context();
+    my $event = $ctx->diag($message);
+
+=head1 ACCESSORS
+
+=over 4
+
+=item $diag->message
+
+The message for the diag.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Event/Encoding.pm

@@ -0,0 +1,97 @@
+package Test2::Event::Encoding;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+use Carp qw/croak/;
+
+BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) }
+use Test2::Util::HashBase qw/encoding/;
+
+sub init {
+    my $self = shift;
+    defined $self->{+ENCODING} or croak "'encoding' is a required attribute";
+}
+
+sub summary { 'Encoding set to ' . $_[0]->{+ENCODING} }
+
+sub facet_data {
+    my $self = shift;
+    my $out = $self->common_facet_data;
+    $out->{control}->{encoding} = $self->{+ENCODING};
+    $out->{about}->{details} = $self->summary;
+    return $out;
+}
+
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Event::Encoding - Set the encoding for the output stream
+
+=head1 DESCRIPTION
+
+The encoding event is generated when a test file wants to specify the encoding
+to be used when formatting its output. This event is intended to be produced
+by formatter classes and used for interpreting test names, message contents,
+etc.
+
+=head1 SYNOPSIS
+
+    use Test2::API qw/context/;
+    use Test2::Event::Encoding;
+
+    my $ctx = context();
+    my $event = $ctx->send_event('Encoding', encoding => 'UTF-8');
+
+=head1 METHODS
+
+Inherits from L<Test2::Event>. Also defines:
+
+=over 4
+
+=item $encoding = $e->encoding
+
+The encoding being specified.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Event/Fail.pm

@@ -0,0 +1,118 @@
+package Test2::Event::Fail;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+use Test2::EventFacet::Info;
+
+BEGIN {
+    require Test2::Event;
+    our @ISA = qw(Test2::Event);
+    *META_KEY = \&Test2::Util::ExternalMeta::META_KEY;
+}
+
+use Test2::Util::HashBase qw{ -name -info };
+
+#############
+# Old API
+sub summary          { "fail" }
+sub increments_count { 1 }
+sub diagnostics      { 0 }
+sub no_display       { 0 }
+sub subtest_id       { undef }
+sub terminate        { () }
+sub global           { () }
+sub sets_plan        { () }
+
+sub causes_fail {
+    my $self = shift;
+    return 0 if $self->{+AMNESTY} && @{$self->{+AMNESTY}};
+    return 1;
+}
+
+#############
+# New API
+
+sub add_info {
+    my $self = shift;
+
+    for my $in (@_) {
+        $in = {%$in} if ref($in) ne 'ARRAY';
+        $in = Test2::EventFacet::Info->new($in);
+
+        push @{$self->{+INFO}} => $in;
+    }
+}
+
+sub facet_data {
+    my $self = shift;
+    my $out = $self->common_facet_data;
+
+    $out->{about}->{details} = 'fail';
+
+    $out->{assert} = {pass => 0, details => $self->{+NAME}};
+
+    $out->{info} = [map {{ %{$_} }} @{$self->{+INFO}}] if $self->{+INFO};
+
+    return $out;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Event::Fail - Event for a simple failed assertion
+
+=head1 DESCRIPTION
+
+This is an optimal representation of a failed assertion.
+
+=head1 SYNOPSIS
+
+    use Test2::API qw/context/;
+
+    sub fail {
+        my ($name) = @_;
+        my $ctx = context();
+        $ctx->fail($name);
+        $ctx->release;
+    }
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Event/Generic.pm

@@ -0,0 +1,280 @@
+package Test2::Event::Generic;
+use strict;
+use warnings;
+
+use Carp qw/croak/;
+use Scalar::Util qw/reftype/;
+
+our $VERSION = '1.302162';
+
+BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) }
+use Test2::Util::HashBase;
+
+my @FIELDS = qw{
+    causes_fail increments_count diagnostics no_display callback terminate
+    global sets_plan summary facet_data
+};
+my %DEFAULTS = (
+    causes_fail      => 0,
+    increments_count => 0,
+    diagnostics      => 0,
+    no_display       => 0,
+);
+
+sub init {
+    my $self = shift;
+
+    for my $field (@FIELDS) {
+        my $val = defined $self->{$field} ? delete $self->{$field} : $DEFAULTS{$field};
+        next unless defined $val;
+
+        my $set = "set_$field";
+        $self->$set($val);
+    }
+}
+
+for my $field (@FIELDS) {
+    no strict 'refs';
+
+    *$field = sub { exists $_[0]->{$field} ? $_[0]->{$field} : () }
+        unless exists &{$field};
+
+    *{"set_$field"} = sub { $_[0]->{$field} = $_[1] }
+        unless exists &{"set_$field"};
+}
+
+sub can {
+    my $self = shift;
+    my ($name) = @_;
+    return $self->SUPER::can($name) unless $name eq 'callback';
+    return $self->{callback} || \&Test2::Event::callback;
+}
+
+sub facet_data {
+    my $self = shift;
+    return $self->{facet_data} || $self->SUPER::facet_data();
+}
+
+sub summary {
+    my $self = shift;
+    return $self->{summary} if defined $self->{summary};
+    $self->SUPER::summary();
+}
+
+sub sets_plan {
+    my $self = shift;
+    return unless $self->{sets_plan};
+    return @{$self->{sets_plan}};
+}
+
+sub callback {
+    my $self = shift;
+    my $cb = $self->{callback} || return;
+    $self->$cb(@_);
+}
+
+sub set_global {
+    my $self = shift;
+    my ($bool) = @_;
+
+    if(!defined $bool) {
+        delete $self->{global};
+        return undef;
+    }
+
+    $self->{global} = $bool;
+}
+
+sub set_callback {
+    my $self = shift;
+    my ($cb) = @_;
+
+    if(!defined $cb) {
+        delete $self->{callback};
+        return undef;
+    }
+
+    croak "callback must be a code reference"
+        unless ref($cb) && reftype($cb) eq 'CODE';
+
+    $self->{callback} = $cb;
+}
+
+sub set_terminate {
+    my $self = shift;
+    my ($exit) = @_;
+
+    if(!defined $exit) {
+        delete $self->{terminate};
+        return undef;
+    }
+
+    croak "terminate must be a positive integer"
+       unless $exit =~ m/^\d+$/;
+
+    $self->{terminate} = $exit;
+}
+
+sub set_sets_plan {
+    my $self = shift;
+    my ($plan) = @_;
+
+    if(!defined $plan) {
+        delete $self->{sets_plan};
+        return undef;
+    }
+
+    croak "'sets_plan' must be an array reference"
+        unless ref($plan) && reftype($plan) eq 'ARRAY';
+
+    $self->{sets_plan} = $plan;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Event::Generic - Generic event type.
+
+=head1 DESCRIPTION
+
+This is a generic event that lets you customize all fields in the event API.
+This is useful if you have need for a custom event that does not make sense as
+a published reusable event subclass.
+
+=head1 SYNOPSIS
+
+    use Test2::API qw/context/;
+
+    sub send_custom_fail {
+        my $ctx = shift;
+
+        $ctx->send_event('Generic', causes_fail => 1, summary => 'The sky is falling');
+
+        $ctx->release;
+    }
+
+    send_custom_fail();
+
+=head1 METHODS
+
+=over 4
+
+=item $e->facet_data($data)
+
+=item $data = $e->facet_data
+
+Get or set the facet data (see L<Test2::Event>). If no facet_data is set then
+C<< Test2::Event->facet_data >> will be called to produce facets from the other
+data.
+
+=item $e->callback($hub)
+
+Call the custom callback if one is set, otherwise this does nothing.
+
+=item $e->set_callback(sub { ... })
+
+Set the custom callback. The custom callback must be a coderef. The first
+argument to your callback will be the event itself, the second will be the
+L<Test2::Event::Hub> that is using the callback.
+
+=item $bool = $e->causes_fail
+
+=item $e->set_causes_fail($bool)
+
+Get/Set the C<causes_fail> attribute. This defaults to C<0>.
+
+=item $bool = $e->diagnostics
+
+=item $e->set_diagnostics($bool)
+
+Get/Set the C<diagnostics> attribute. This defaults to C<0>.
+
+=item $bool_or_undef = $e->global
+
+=item @bool_or_empty = $e->global
+
+=item $e->set_global($bool_or_undef)
+
+Get/Set the C<diagnostics> attribute. This defaults to an empty list which is
+undef in scalar context.
+
+=item $bool = $e->increments_count
+
+=item $e->set_increments_count($bool)
+
+Get/Set the C<increments_count> attribute. This defaults to C<0>.
+
+=item $bool = $e->no_display
+
+=item $e->set_no_display($bool)
+
+Get/Set the C<no_display> attribute. This defaults to C<0>.
+
+=item @plan = $e->sets_plan
+
+Get the plan if this event sets one. The plan is a list of up to 3 items:
+C<($count, $directive, $reason)>. C<$count> must be defined, the others may be
+undef, or may not exist at all.
+
+=item $e->set_sets_plan(\@plan)
+
+Set the plan. You must pass in an arrayref with up to 3 elements.
+
+=item $summary = $e->summary
+
+=item $e->set_summary($summary_or_undef)
+
+Get/Set the summary. This will default to the event package
+C<'Test2::Event::Generic'>. You can set it to any value. Setting this to
+C<undef> will reset it to the default.
+
+=item $int_or_undef = $e->terminate
+
+=item @int_or_empty = $e->terminate
+
+=item $e->set_terminate($int_or_undef)
+
+This will get/set the C<terminate> attribute. This defaults to undef in scalar
+context, or an empty list in list context. Setting this to undef will clear it
+completely. This must be set to a positive integer (0 or larger).
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Event/Note.pm

@@ -0,0 +1,97 @@
+package Test2::Event::Note;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+
+BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) }
+use Test2::Util::HashBase qw/message/;
+
+sub init {
+    $_[0]->{+MESSAGE} = 'undef' unless defined $_[0]->{+MESSAGE};
+}
+
+sub summary { $_[0]->{+MESSAGE} }
+
+sub facet_data {
+    my $self = shift;
+
+    my $out = $self->common_facet_data;
+
+    $out->{info} = [
+        {
+            tag     => 'NOTE',
+            debug   => 0,
+            details => $self->{+MESSAGE},
+        }
+    ];
+
+    return $out;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Event::Note - Note event type
+
+=head1 DESCRIPTION
+
+Notes, typically rendered to STDOUT.
+
+=head1 SYNOPSIS
+
+    use Test2::API qw/context/;
+    use Test2::Event::Note;
+
+    my $ctx = context();
+    my $event = $ctx->Note($message);
+
+=head1 ACCESSORS
+
+=over 4
+
+=item $note->message
+
+The message for the note.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Event/Pass.pm

@@ -0,0 +1,114 @@
+package Test2::Event::Pass;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+use Test2::EventFacet::Info;
+
+BEGIN {
+    require Test2::Event;
+    our @ISA = qw(Test2::Event);
+    *META_KEY = \&Test2::Util::ExternalMeta::META_KEY;
+}
+
+use Test2::Util::HashBase qw{ -name -info };
+
+##############
+# Old API
+sub summary          { "pass" }
+sub increments_count { 1 }
+sub causes_fail      { 0 }
+sub diagnostics      { 0 }
+sub no_display       { 0 }
+sub subtest_id       { undef }
+sub terminate        { () }
+sub global           { () }
+sub sets_plan        { () }
+
+##############
+# New API
+
+sub add_info {
+    my $self = shift;
+
+    for my $in (@_) {
+        $in = {%$in} if ref($in) ne 'ARRAY';
+        $in = Test2::EventFacet::Info->new($in);
+
+        push @{$self->{+INFO}} => $in;
+    }
+}
+
+sub facet_data {
+    my $self = shift;
+
+    my $out = $self->common_facet_data;
+
+    $out->{about}->{details} = 'pass';
+
+    $out->{assert} = {pass => 1, details => $self->{+NAME}};
+
+    $out->{info} = [map {{ %{$_} }} @{$self->{+INFO}}] if $self->{+INFO};
+
+    return $out;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Event::Pass - Event for a simple passing assertion
+
+=head1 DESCRIPTION
+
+This is an optimal representation of a passing assertion.
+
+=head1 SYNOPSIS
+
+    use Test2::API qw/context/;
+
+    sub pass {
+        my ($name) = @_;
+        my $ctx = context();
+        $ctx->pass($name);
+        $ctx->release;
+    }
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Event/Plan.pm

@@ -0,0 +1,169 @@
+package Test2::Event::Plan;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+
+BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) }
+use Test2::Util::HashBase qw{max directive reason};
+
+use Carp qw/confess/;
+
+my %ALLOWED = (
+    'SKIP'    => 1,
+    'NO PLAN' => 1,
+);
+
+sub init {
+    if ($_[0]->{+DIRECTIVE}) {
+        $_[0]->{+DIRECTIVE} = 'SKIP'    if $_[0]->{+DIRECTIVE} eq 'skip_all';
+        $_[0]->{+DIRECTIVE} = 'NO PLAN' if $_[0]->{+DIRECTIVE} eq 'no_plan';
+
+        confess "'" . $_[0]->{+DIRECTIVE} . "' is not a valid plan directive"
+            unless $ALLOWED{$_[0]->{+DIRECTIVE}};
+    }
+    else {
+        confess "Cannot have a reason without a directive!"
+            if defined $_[0]->{+REASON};
+
+        confess "No number of tests specified"
+            unless defined $_[0]->{+MAX};
+
+        confess "Plan test count '" . $_[0]->{+MAX}  . "' does not appear to be a valid positive integer"
+            unless $_[0]->{+MAX} =~ m/^\d+$/;
+
+        $_[0]->{+DIRECTIVE} = '';
+    }
+}
+
+sub sets_plan {
+    my $self = shift;
+    return (
+        $self->{+MAX},
+        $self->{+DIRECTIVE},
+        $self->{+REASON},
+    );
+}
+
+sub terminate {
+    my $self = shift;
+    # On skip_all we want to terminate the hub
+    return 0 if $self->{+DIRECTIVE} && $self->{+DIRECTIVE} eq 'SKIP';
+    return undef;
+}
+
+sub summary {
+    my $self = shift;
+    my $max = $self->{+MAX};
+    my $directive = $self->{+DIRECTIVE};
+    my $reason = $self->{+REASON};
+
+    return "Plan is $max assertions"
+        if $max || !$directive;
+
+    return "Plan is '$directive', $reason"
+        if $reason;
+
+    return "Plan is '$directive'";
+}
+
+sub facet_data {
+    my $self = shift;
+
+    my $out = $self->common_facet_data;
+
+    $out->{control}->{terminate} = $self->{+DIRECTIVE} eq 'SKIP' ? 0 : undef
+        unless defined $out->{control}->{terminate};
+
+    $out->{plan} = {count => $self->{+MAX}};
+    $out->{plan}->{details} = $self->{+REASON} if defined $self->{+REASON};
+
+    if (my $dir = $self->{+DIRECTIVE}) {
+        $out->{plan}->{skip} = 1 if $dir eq 'SKIP';
+        $out->{plan}->{none} = 1 if $dir eq 'NO PLAN';
+    }
+
+    return $out;
+}
+
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Event::Plan - The event of a plan
+
+=head1 DESCRIPTION
+
+Plan events are fired off whenever a plan is declared, done testing is called,
+or a subtext completes.
+
+=head1 SYNOPSIS
+
+    use Test2::API qw/context/;
+    use Test2::Event::Plan;
+
+    my $ctx = context();
+
+    # Plan for 10 tests to run
+    my $event = $ctx->plan(10);
+
+    # Plan to skip all tests (will exit 0)
+    $ctx->plan(0, skip_all => "These tests need to be skipped");
+
+=head1 ACCESSORS
+
+=over 4
+
+=item $num = $plan->max
+
+Get the number of expected tests
+
+=item $dir = $plan->directive
+
+Get the directive (such as TODO, skip_all, or no_plan).
+
+=item $reason = $plan->reason
+
+Get the reason for the directive.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Event/Skip.pm

@@ -0,0 +1,127 @@
+package Test2::Event::Skip;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+
+BEGIN { require Test2::Event::Ok; our @ISA = qw(Test2::Event::Ok) }
+use Test2::Util::HashBase qw{reason};
+
+sub init {
+    my $self = shift;
+    $self->SUPER::init;
+    $self->{+EFFECTIVE_PASS} = 1;
+}
+
+sub causes_fail { 0 }
+
+sub summary {
+    my $self = shift;
+    my $out = $self->SUPER::summary(@_);
+
+    if (my $reason = $self->reason) {
+        $out .= " (SKIP: $reason)";
+    }
+    else {
+        $out .= " (SKIP)";
+    }
+
+    return $out;
+}
+
+sub extra_amnesty {
+    my $self = shift;
+
+    my @out;
+
+    push @out => {
+        tag       => 'TODO',
+        details   => $self->{+TODO},
+    } if defined $self->{+TODO};
+
+    push @out => {
+        tag       => 'skip',
+        details   => $self->{+REASON},
+        inherited => 0,
+    };
+
+    return @out;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Event::Skip - Skip event type
+
+=head1 DESCRIPTION
+
+Skip events bump test counts just like L<Test2::Event::Ok> events, but
+they can never fail.
+
+=head1 SYNOPSIS
+
+    use Test2::API qw/context/;
+    use Test2::Event::Skip;
+
+    my $ctx = context();
+    my $event = $ctx->skip($name, $reason);
+
+or:
+
+    my $ctx   = context();
+    my $event = $ctx->send_event(
+        'Skip',
+        name   => $name,
+        reason => $reason,
+    );
+
+=head1 ACCESSORS
+
+=over 4
+
+=item $reason = $e->reason
+
+The original true/false value of whatever was passed into the event (but
+reduced down to 1 or 0).
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
+
+=cut

my_container_sandbox/usr/share/perl/5.30.0/Test2/Event/Subtest.pm

@@ -0,0 +1,160 @@
+package Test2::Event::Subtest;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+BEGIN { require Test2::Event::Ok; our @ISA = qw(Test2::Event::Ok) }
+use Test2::Util::HashBase qw{subevents buffered subtest_id subtest_uuid};
+
+sub init {
+    my $self = shift;
+    $self->SUPER::init();
+    $self->{+SUBEVENTS} ||= [];
+    if ($self->{+EFFECTIVE_PASS}) {
+        $_->set_effective_pass(1) for grep { $_->can('effective_pass') } @{$self->{+SUBEVENTS}};
+    }
+}
+
+{
+    no warnings 'redefine';
+
+    sub set_subevents {
+        my $self      = shift;
+        my @subevents = @_;
+
+        if ($self->{+EFFECTIVE_PASS}) {
+            $_->set_effective_pass(1) for grep { $_->can('effective_pass') } @subevents;
+        }
+
+        $self->{+SUBEVENTS} = \@subevents;
+    }
+
+    sub set_effective_pass {
+        my $self = shift;
+        my ($pass) = @_;
+
+        if ($pass) {
+            $_->set_effective_pass(1) for grep { $_->can('effective_pass') } @{$self->{+SUBEVENTS}};
+        }
+        elsif ($self->{+EFFECTIVE_PASS} && !$pass) {
+            for my $s (grep { $_->can('effective_pass') } @{$self->{+SUBEVENTS}}) {
+                $_->set_effective_pass(0) unless $s->can('todo') && defined $s->todo;
+            }
+        }
+
+        $self->{+EFFECTIVE_PASS} = $pass;
+    }
+}
+
+sub summary {
+    my $self = shift;
+
+    my $name = $self->{+NAME} || "Nameless Subtest";
+
+    my $todo = $self->{+TODO};
+    if ($todo) {
+        $name .= " (TODO: $todo)";
+    }
+    elsif (defined $todo) {
+        $name .= " (TODO)";
+    }
+
+    return $name;
+}
+
+sub facet_data {
+    my $self = shift;
+
+    my $out = $self->SUPER::facet_data();
+
+    $out->{parent} = {
+        hid      => $self->subtest_id,
+        children => [map {$_->facet_data} @{$self->{+SUBEVENTS}}],
+        buffered => $self->{+BUFFERED},
+    };
+
+    return $out;
+}
+
+sub add_amnesty {
+    my $self = shift;
+
+    for my $am (@_) {
+        $am = {%$am} if ref($am) ne 'ARRAY';
+        $am = Test2::EventFacet::Amnesty->new($am);
+
+        push @{$self->{+AMNESTY}} => $am;
+
+        for my $e (@{$self->{+SUBEVENTS}}) {
+            $e->add_amnesty($am->clone(inherited => 1));
+        }
+    }
+}
+
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Event::Subtest - Event for subtest types
+
+=head1 DESCRIPTION
+
+This class represents a subtest. This class is a subclass of
+L<Test2::Event::Ok>.
+
+=head1 ACCESSORS
+
+This class inherits from L<Test2::Event::Ok>.
+
+=over 4
+
+=item $arrayref = $e->subevents
+
+Returns the arrayref containing all the events from the subtest
+
+=item $bool = $e->buffered
+
+True if the subtest is buffered, that is all subevents render at once. If this
+is false it means all subevents render as they are produced.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Event/V2.pm

@@ -0,0 +1,238 @@
+package Test2::Event::V2;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+use Scalar::Util qw/reftype/;
+use Carp qw/croak/;
+
+BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) }
+
+use Test2::Util::Facets2Legacy qw{
+    causes_fail diagnostics global increments_count no_display sets_plan
+    subtest_id summary terminate
+};
+
+use Test2::Util::HashBase qw/-about/;
+
+sub non_facet_keys {
+    return (
+        +UUID,
+        Test2::Util::ExternalMeta::META_KEY(),
+    );
+}
+
+sub init {
+    my $self = shift;
+
+    my $uuid;
+    if ($uuid = $self->{+UUID}) {
+        croak "uuid '$uuid' passed to constructor, but uuid '$self->{+ABOUT}->{uuid}' is already set in the 'about' facet"
+            if $self->{+ABOUT}->{uuid} && $self->{+ABOUT}->{uuid} ne $uuid;
+
+        $self->{+ABOUT}->{uuid} = $uuid;
+    }
+    elsif ($uuid = $self->{+ABOUT}->{uuid}) {
+        $self->SUPER::set_uuid($uuid);
+    }
+
+    # Clone the trace, make sure it is blessed
+    if (my $trace = $self->{+TRACE}) {
+        $self->{+TRACE} = Test2::EventFacet::Trace->new(%$trace);
+    }
+}
+
+sub set_uuid {
+    my $self = shift;
+    my ($uuid) = @_;
+    $self->{+ABOUT}->{uuid} = $uuid;
+    $self->SUPER::set_uuid($uuid);
+}
+
+sub facet_data {
+    my $self = shift;
+    my $f = { %{$self} };
+
+    delete $f->{$_} for $self->non_facet_keys;
+
+    my %out;
+    for my $k (keys %$f) {
+        next if substr($k, 0, 1) eq '_';
+
+        my $data = $f->{$k};
+        my $is_list = reftype($data) eq 'ARRAY';
+        $out{$k} = $is_list ? [ map { {%{$_}} } @$data ] : {%$data};
+    }
+
+    if (my $meta = $self->meta_facet_data) {
+        $out{meta} = {%$meta, %{$out{meta} || {}}};
+    }
+
+    return \%out;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Event::V2 - Second generation event.
+
+=head1 DESCRIPTION
+
+This is the event type that should be used instead of L<Test2::Event> or its
+legacy subclasses.
+
+=head1 SYNOPSIS
+
+=head2 USING A CONTEXT
+
+    use Test2::API qw/context/;
+
+    sub my_tool {
+        my $ctx = context();
+
+        my $event = $ctx->send_ev2(info => [{tag => 'NOTE', details => "This is a note"}]);
+
+        $ctx->release;
+
+        return $event;
+    }
+
+=head2 USING THE CONSTRUCTOR
+
+    use Test2::Event::V2;
+
+    my $e = Test2::Event::V2->new(
+        trace => {frame => [$PKG, $FILE, $LINE, $SUBNAME]},
+        info  => [{tag => 'NOTE', details => "This is a note"}],
+    );
+
+=head1 METHODS
+
+This class inherits from L<Test2::Event>.
+
+=over 4
+
+=item $fd = $e->facet_data()
+
+This will return a hashref of facet data. Each facet hash will be a shallow
+copy of the original.
+
+=item $about = $e->about()
+
+This will return the 'about' facet hashref.
+
+B<NOTE:> This will return the internal hashref, not a copy.
+
+=item $trace = $e->trace()
+
+This will return the 'trace' facet, normally blessed (but this is not enforced
+when the trace is set using C<set_trace()>.
+
+B<NOTE:> This will return the internal trace, not a copy.
+
+=back
+
+=head2 MUTATION
+
+=over 4
+
+=item $e->add_amnesty({...})
+
+Inherited from L<Test2::Event>. This can be used to add 'amnesty' facets to an
+existing event. Each new item is added to the B<END> of the list.
+
+B<NOTE:> Items B<ARE> blessed when added.
+
+=item $e->add_hub({...})
+
+Inherited from L<Test2::Event>. This is used by hubs to stamp events as they
+pass through. New items are added to the B<START> of the list.
+
+B<NOTE:> Items B<ARE NOT> blessed when added.
+
+=item $e->set_uuid($UUID)
+
+Inherited from L<Test2::Event>, overridden to also vivify/mutate the 'about'
+facet.
+
+=item $e->set_trace($trace)
+
+Inherited from L<Test2::Event> which allows you to change the trace.
+
+B<Note:> This method does not bless/clone the trace for you. Many things will
+expect the trace to be blessed, so you should probably do that.
+
+=back
+
+=head2 LEGACY SUPPORT METHODS
+
+These are all imported from L<Test2::Util::Facets2Legacy>, see that module or
+L<Test2::Event> for documentation on what they do.
+
+=over 4
+
+=item causes_fail
+
+=item diagnostics
+
+=item global
+
+=item increments_count
+
+=item no_display
+
+=item sets_plan
+
+=item subtest_id
+
+=item summary
+
+=item terminate
+
+=back
+
+=head1 THIRD PARTY META-DATA
+
+This object consumes L<Test2::Util::ExternalMeta> which provides a consistent
+way for you to attach meta-data to instances of this class. This is useful for
+tools, plugins, and other extensions.
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Event/Waiting.pm

@@ -0,0 +1,76 @@
+package Test2::Event::Waiting;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+
+BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) }
+use Test2::Util::HashBase;
+
+sub global { 1 };
+
+sub summary { "IPC is waiting for children to finish..." }
+
+sub facet_data {
+    my $self = shift;
+
+    my $out = $self->common_facet_data;
+
+    push @{$out->{info}} => {
+        tag     => 'INFO',
+        debug   => 0,
+        details => $self->summary,
+    };
+
+    return $out;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Event::Waiting - Tell all procs/threads it is time to be done
+
+=head1 DESCRIPTION
+
+This event has no data of its own. This event is sent out by the IPC system
+when the main process/thread is ready to end.
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/EventFacet/About.pm

@@ -0,0 +1,92 @@
+package Test2::EventFacet::About;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+BEGIN { require Test2::EventFacet; our @ISA = qw(Test2::EventFacet) }
+use Test2::Util::HashBase qw{ -package -no_display -uuid -eid };
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet::About - Facet with event details.
+
+=head1 DESCRIPTION
+
+This facet has information about the event, such as event package.
+
+=head1 FIELDS
+
+=over 4
+
+=item $string = $about->{details}
+
+=item $string = $about->details()
+
+Summary about the event.
+
+=item $package = $about->{package}
+
+=item $package = $about->package()
+
+Event package name.
+
+=item $bool = $about->{no_display}
+
+=item $bool = $about->no_display()
+
+True if the event should be skipped by formatters.
+
+=item $uuid = $about->{uuid}
+
+=item $uuid = $about->uuid()
+
+Will be set to a uuid if uuid tagging was enabled.
+
+=item $uuid = $about->{eid}
+
+=item $uuid = $about->eid()
+
+A unique (for the test job) identifier for the event.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/EventFacet/Amnesty.pm

@@ -0,0 +1,91 @@
+package Test2::EventFacet::Amnesty;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+sub is_list { 1 }
+
+BEGIN { require Test2::EventFacet; our @ISA = qw(Test2::EventFacet) }
+use Test2::Util::HashBase qw{ -tag -inherited };
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet::Amnesty - Facet for assertion amnesty.
+
+=head1 DESCRIPTION
+
+This package represents what is expected in units of amnesty.
+
+=head1 NOTES
+
+This facet appears in a list instead of being a single item.
+
+=head1 FIELDS
+
+=over 4
+
+=item $string = $amnesty->{details}
+
+=item $string = $amnesty->details()
+
+Human readable explanation of why amnesty was granted.
+
+Example: I<Not implemented yet, will fix>
+
+=item $short_string = $amnesty->{tag}
+
+=item $short_string = $amnesty->tag()
+
+Short string (usually 10 characters or less, not enforced, but may be truncated
+by renderers) categorizing the amnesty.
+
+=item $bool = $amnesty->{inherited}
+
+=item $bool = $amnesty->inherited()
+
+This will be true if the amnesty was granted to a parent event and inherited by
+this event, which is a child, such as an assertion within a subtest that is
+marked todo.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/EventFacet/Assert.pm

@@ -0,0 +1,93 @@
+package Test2::EventFacet::Assert;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+BEGIN { require Test2::EventFacet; our @ISA = qw(Test2::EventFacet) }
+use Test2::Util::HashBase qw{ -pass -no_debug -number };
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet::Assert - Facet representing an assertion.
+
+=head1 DESCRIPTION
+
+The assertion facet is provided by any event representing an assertion that was
+made.
+
+=head1 FIELDS
+
+=over 4
+
+=item $string = $assert->{details}
+
+=item $string = $assert->details()
+
+Human readable description of the assertion.
+
+=item $bool = $assert->{pass}
+
+=item $bool = $assert->pass()
+
+True if the assertion passed.
+
+=item $bool = $assert->{no_debug}
+
+=item $bool = $assert->no_debug()
+
+Set this to true if you have provided custom diagnostics and do not want the
+defaults to be displayed.
+
+=item $int = $assert->{number}
+
+=item $int = $assert->number()
+
+(Optional) assertion number. This may be omitted or ignored. This is usually
+only useful when parsing/processing TAP.
+
+B<Note>: This is not set by the Test2 system, assertion number is not known
+until AFTER the assertion has been processed. This attribute is part of the
+spec only for harnesses.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/EventFacet/Control.pm

@@ -0,0 +1,100 @@
+package Test2::EventFacet::Control;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+BEGIN { require Test2::EventFacet; our @ISA = qw(Test2::EventFacet) }
+use Test2::Util::HashBase qw{ -global -terminate -halt -has_callback -encoding };
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet::Control - Facet for hub actions and behaviors.
+
+=head1 DESCRIPTION
+
+This facet is used when the event needs to give instructions to the Test2
+internals.
+
+=head1 FIELDS
+
+=over 4
+
+=item $string = $control->{details}
+
+=item $string = $control->details()
+
+Human readable explanation for the special behavior.
+
+=item $bool = $control->{global}
+
+=item $bool = $control->global()
+
+True if the event is global in nature and should be seen by all hubs.
+
+=item $exit = $control->{terminate}
+
+=item $exit = $control->terminate()
+
+Defined if the test should immediately exit, the value is the exit code and may
+be C<0>.
+
+=item $bool = $control->{halt}
+
+=item $bool = $control->halt()
+
+True if all testing should be halted immediately.
+
+=item $bool = $control->{has_callback}
+
+=item $bool = $control->has_callback()
+
+True if the C<callback($hub)> method on the event should be called.
+
+=item $encoding = $control->{encoding}
+
+=item $encoding = $control->encoding()
+
+This can be used to change the encoding from this event onward.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/EventFacet/Error.pm

@@ -0,0 +1,93 @@
+package Test2::EventFacet::Error;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+sub facet_key { 'errors' }
+sub is_list { 1 }
+
+BEGIN { require Test2::EventFacet; our @ISA = qw(Test2::EventFacet) }
+use Test2::Util::HashBase qw{ -tag -fail };
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet::Error - Facet for errors that need to be shown.
+
+=head1 DESCRIPTION
+
+This facet is used when an event needs to convey errors.
+
+=head1 NOTES
+
+This facet has the hash key C<'errors'>, and is a list of facets instead of a
+single item.
+
+=head1 FIELDS
+
+=over 4
+
+=item $string = $error->{details}
+
+=item $string = $error->details()
+
+Explanation of the error, or the error itself (such as an exception). In perl
+exceptions may be blessed objects, so this field may contain a blessed object.
+
+=item $short_string = $error->{tag}
+
+=item $short_string = $error->tag()
+
+Short tag to categorize the error. This is usually 10 characters or less,
+formatters may truncate longer tags.
+
+=item $bool = $error->{fail}
+
+=item $bool = $error->fail()
+
+Not all errors are fatal, some are displayed having already been handled. Set
+this to true if you want the error to cause the test to fail. Without this the
+error is simply a diagnostics message that has no effect on the overall
+pass/fail result.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/EventFacet/Hub.pm

@@ -0,0 +1,109 @@
+package Test2::EventFacet::Hub;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+sub is_list { 1 }
+sub facet_key { 'hubs' }
+
+BEGIN { require Test2::EventFacet; our @ISA = qw(Test2::EventFacet) }
+use Test2::Util::HashBase qw{-pid -tid -hid -nested -buffered -uuid -ipc};
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet::Hub - Facet for the hubs an event passes through.
+
+=head1 DESCRIPTION
+
+These are a record of the hubs an event passes through. Most recent hub is the
+first one in the list.
+
+=head1 FACET FIELDS
+
+=over 4
+
+=item $string = $trace->{details}
+
+=item $string = $trace->details()
+
+The hub class or subclass
+
+=item $int = $trace->{pid}
+
+=item $int = $trace->pid()
+
+PID of the hub this event was sent to.
+
+=item $int = $trace->{tid}
+
+=item $int = $trace->tid()
+
+The thread ID of the hub the event was sent to.
+
+=item $hid = $trace->{hid}
+
+=item $hid = $trace->hid()
+
+The ID of the hub that the event was send to.
+
+=item $huuid = $trace->{huuid}
+
+=item $huuid = $trace->huuid()
+
+The UUID of the hub that the event was sent to.
+
+=item $int = $trace->{nested}
+
+=item $int = $trace->nested()
+
+How deeply nested the hub was.
+
+=item $bool = $trace->{buffered}
+
+=item $bool = $trace->buffered()
+
+True if the event was buffered and not sent to the formatter independent of a
+parent (This should never be set when nested is C<0> or C<undef>).
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/EventFacet/Info.pm

@@ -0,0 +1,132 @@
+package Test2::EventFacet::Info;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+sub is_list { 1 }
+
+BEGIN { require Test2::EventFacet; our @ISA = qw(Test2::EventFacet) }
+use Test2::Util::HashBase qw{-tag -debug -important -table};
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet::Info - Facet for information a developer might care about.
+
+=head1 DESCRIPTION
+
+This facet represents messages intended for humans that will help them either
+understand a result, or diagnose a failure.
+
+=head1 NOTES
+
+This facet appears in a list instead of being a single item.
+
+=head1 FIELDS
+
+=over 4
+
+=item $string_or_structure = $info->{details}
+
+=item $string_or_structure = $info->details()
+
+Human readable string or data structure, this is the information to display.
+Formatters are free to render the structures however they please. This may
+contain a blessed object.
+
+If the C<table> attribute (see below) is set then a renderer may choose to
+display the table instead of the details.
+
+=item $structure = $info->{table}
+
+=item $structure = $info->table()
+
+If the data the C<info> facet needs to convey can be represented as a table
+then the data may be placed in this attribute in a more raw form for better
+display. The data must also be represented in the C<details> attribute for
+renderers which do not support rendering tables directly.
+
+The table structure:
+
+    my %table = {
+        header => [ 'column 1 header', 'column 2 header', ... ], # Optional
+
+        rows => [
+            ['row 1 column 1', 'row 1, column 2', ... ],
+            ['row 2 column 1', 'row 2, column 2', ... ],
+            ...
+        ],
+
+        # Allow the renderer to hide empty columns when true, Optional
+        collapse => $BOOL,
+
+        # List by name or number columns that should never be collapsed
+        no_collapse => \@LIST,
+    }
+
+=item $short_string = $info->{tag}
+
+=item $short_string = $info->tag()
+
+Short tag to categorize the info. This is usually 10 characters or less,
+formatters may truncate longer tags.
+
+=item $bool = $info->{debug}
+
+=item $bool = $info->debug()
+
+Set this to true if the message is critical, or explains a failure. This is
+info that should be displayed by formatters even in less-verbose modes.
+
+When false the information is not considered critical and may not be rendered
+in less-verbose modes.
+
+=item $bool = $info->{important}
+
+=item $bool = $info->important
+
+This should be set for non debug messages that are still important enough to
+show when a formatter is in quiet mode. A formatter should send these to STDOUT
+not STDERR, but should show them even in non-verbose mode.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/EventFacet/Meta.pm

@@ -0,0 +1,104 @@
+package Test2::EventFacet::Meta;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+BEGIN { require Test2::EventFacet; our @ISA = qw(Test2::EventFacet) }
+use vars qw/$AUTOLOAD/;
+
+# replace set_details
+{
+    no warnings 'redefine';
+    sub set_details { $_[0]->{'set_details'} }
+}
+
+sub can {
+    my $self = shift;
+    my ($name) = @_;
+
+    my $existing = $self->SUPER::can($name);
+    return $existing if $existing;
+
+    # Only vivify when called on an instance, do not vivify for a class. There
+    # are a lot of magic class methods used in things like serialization (or
+    # the forks.pm module) which cause problems when vivified.
+    return undef unless ref($self);
+
+    my $sub = sub { $_[0]->{$name} };
+    {
+        no strict 'refs';
+        *$name = $sub;
+    }
+
+    return $sub;
+}
+
+sub AUTOLOAD {
+    my $name = $AUTOLOAD;
+    $name =~ s/^.*:://g;
+    my $sub = $_[0]->can($name);
+    goto &$sub;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet::Meta - Facet for meta-data
+
+=head1 DESCRIPTION
+
+This facet can contain any random meta-data that has been attached to the
+event.
+
+=head1 METHODS AND FIELDS
+
+Any/all fields and accessors are autovivified into existence. There is no way
+to know what metadata may be added, so any is allowed.
+
+=over 4
+
+=item $anything = $meta->{anything}
+
+=item $anything = $meta->anything()
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/EventFacet/Parent.pm

@@ -0,0 +1,98 @@
+package Test2::EventFacet::Parent;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+use Carp qw/confess/;
+
+BEGIN { require Test2::EventFacet; our @ISA = qw(Test2::EventFacet) }
+use Test2::Util::HashBase qw{ -hid -children -buffered };
+
+sub init {
+    confess "Attribute 'hid' must be set"
+        unless defined $_[0]->{+HID};
+
+    $_[0]->{+CHILDREN} ||= [];
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet::Parent - Facet for events contains other events
+
+=head1 DESCRIPTION
+
+This facet is used when an event contains other events, such as a subtest.
+
+=head1 FIELDS
+
+=over 4
+
+=item $string = $parent->{details}
+
+=item $string = $parent->details()
+
+Human readable description of the event.
+
+=item $hid = $parent->{hid}
+
+=item $hid = $parent->hid()
+
+Hub ID of the hub that is represented in the parent-child relationship.
+
+=item $arrayref = $parent->{children}
+
+=item $arrayref = $parent->children()
+
+Arrayref containing the facet-data hashes of events nested under this one.
+
+I<To get the actual events you need to get them from the parent event directly>
+
+=item $bool = $parent->{buffered}
+
+=item $bool = $parent->buffered()
+
+True if the subtest is buffered (meaning the formatter has probably not seen
+them yet).
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/EventFacet/Plan.pm

@@ -0,0 +1,94 @@
+package Test2::EventFacet::Plan;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+BEGIN { require Test2::EventFacet; our @ISA = qw(Test2::EventFacet) }
+use Test2::Util::HashBase qw{ -count -skip -none };
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet::Plan - Facet for setting the plan
+
+=head1 DESCRIPTION
+
+Events use this facet when they need to set the plan.
+
+=head1 FIELDS
+
+=over 4
+
+=item $string = $plan->{details}
+
+=item $string = $plan->details()
+
+Human readable explanation for the plan being set. This is normally not
+rendered by most formatters except when the C<skip> field is also set.
+
+=item $positive_int = $plan->{count}
+
+=item $positive_int = $plan->count()
+
+Set the number of expected assertions. This should usually be set to C<0> when
+C<skip> or C<none> are also set.
+
+=item $bool = $plan->{skip}
+
+=item $bool = $plan->skip()
+
+When true the entire test should be skipped. This is usually paired with an
+explanation in the C<details> field, and a C<control> facet that has
+C<terminate> set to C<0>.
+
+=item $bool = $plan->{none}
+
+=item $bool = $plan->none()
+
+This is mainly used by legacy L<Test::Builder> tests which set the plan to C<no
+plan>, a construct that predates the much better C<done_testing()>.
+
+If you are using this in non-legacy code you may need to reconsider the course
+of your life, maybe a hermitage would suite you?
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/EventFacet/Render.pm

@@ -0,0 +1,106 @@
+package Test2::EventFacet::Render;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+sub is_list { 1 }
+
+BEGIN { require Test2::EventFacet; our @ISA = qw(Test2::EventFacet) }
+use Test2::Util::HashBase qw{ -tag -facet -mode };
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet::Render - Facet that dictates how to render an event.
+
+=head1 DESCRIPTION
+
+This facet is used to dictate how the event should be rendered by the standard
+test2 rendering tools. If this facet is present then ONLY what is specified by
+it will be rendered. It is assumed that anything important or note-worthy will
+be present here, no other facets will be considered for rendering/display.
+
+This facet is a list type, you can add as many items as needed.
+
+=head1 FIELDS
+
+=over 4
+
+=item $string = $render->[#]->{details}
+
+=item $string = $render->[#]->details()
+
+Human readable text for display.
+
+=item $string = $render->[#]->{tag}
+
+=item $string = $render->[#]->tag()
+
+Tag that should prefix/identify the main text.
+
+=item $string = $render->[#]->{facet}
+
+=item $string = $render->[#]->facet()
+
+Optional, if the display text was generated from another facet this should
+state what facet it was.
+
+=item $mode = $render->[#]->{mode}
+
+=item $mode = $render->[#]->mode()
+
+=over 4
+
+=item calculated
+
+Calculated means the facet was generated from another facet. Calculated facets
+may be cleared and regenerated whenever the event state changes.
+
+=item replace
+
+Replace means the facet is intended to replace the normal rendering of the
+event.
+
+=back
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/EventFacet/Trace.pm

@@ -0,0 +1,279 @@
+package Test2::EventFacet::Trace;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+BEGIN { require Test2::EventFacet; our @ISA = qw(Test2::EventFacet) }
+
+use Test2::Util qw/get_tid pkg_to_file gen_uid/;
+use Carp qw/confess/;
+
+use Test2::Util::HashBase qw{^frame ^pid ^tid ^cid -hid -nested details -buffered -uuid -huuid};
+
+{
+    no warnings 'once';
+    *DETAIL = \&DETAILS;
+    *detail = \&details;
+    *set_detail = \&set_details;
+}
+
+sub init {
+    confess "The 'frame' attribute is required"
+        unless $_[0]->{+FRAME};
+
+    $_[0]->{+DETAILS} = delete $_[0]->{detail} if $_[0]->{detail};
+
+    unless (defined($_[0]->{+PID}) || defined($_[0]->{+TID}) || defined($_[0]->{+CID})) {
+        $_[0]->{+PID} = $$        unless defined $_[0]->{+PID};
+        $_[0]->{+TID} = get_tid() unless defined $_[0]->{+TID};
+    }
+}
+
+sub snapshot {
+    my ($orig, @override) = @_;
+    bless {%$orig, @override}, __PACKAGE__;
+}
+
+sub signature {
+    my $self = shift;
+
+    # Signature is only valid if all of these fields are defined, there is no
+    # signature if any is missing. '0' is ok, but '' is not.
+    return join ':' => map { (defined($_) && length($_)) ? $_ : return undef } (
+        $self->{+CID},
+        $self->{+PID},
+        $self->{+TID},
+        $self->{+FRAME}->[1],
+        $self->{+FRAME}->[2],
+    );
+}
+
+sub debug {
+    my $self = shift;
+    return $self->{+DETAILS} if $self->{+DETAILS};
+    my ($pkg, $file, $line) = $self->call;
+    return "at $file line $line";
+}
+
+sub alert {
+    my $self = shift;
+    my ($msg) = @_;
+    warn $msg . ' ' . $self->debug . ".\n";
+}
+
+sub throw {
+    my $self = shift;
+    my ($msg) = @_;
+    die $msg . ' ' . $self->debug . ".\n";
+}
+
+sub call { @{$_[0]->{+FRAME}} }
+
+sub package { $_[0]->{+FRAME}->[0] }
+sub file    { $_[0]->{+FRAME}->[1] }
+sub line    { $_[0]->{+FRAME}->[2] }
+sub subname { $_[0]->{+FRAME}->[3] }
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet::Trace - Debug information for events
+
+=head1 DESCRIPTION
+
+The L<Test2::API::Context> object, as well as all L<Test2::Event> types need to
+have access to information about where they were created.  This object
+represents that information.
+
+=head1 SYNOPSIS
+
+    use Test2::EventFacet::Trace;
+
+    my $trace = Test2::EventFacet::Trace->new(
+        frame => [$package, $file, $line, $subname],
+    );
+
+=head1 FACET FIELDS
+
+=over 4
+
+=item $string = $trace->{details}
+
+=item $string = $trace->details()
+
+Used as a custom trace message that will be used INSTEAD of
+C<< at <FILE> line <LINE> >> when calling C<< $trace->debug >>.
+
+=item $frame = $trace->{frame}
+
+=item $frame = $trace->frame()
+
+Get the call frame arrayref.
+
+=item $int = $trace->{pid}
+
+=item $int = $trace->pid()
+
+The process ID in which the event was generated.
+
+=item $int = $trace->{tid}
+
+=item $int = $trace->tid()
+
+The thread ID in which the event was generated.
+
+=item $id = $trace->{cid}
+
+=item $id = $trace->cid()
+
+The ID of the context that was used to create the event.
+
+=item $uuid = $trace->{uuid}
+
+=item $uuid = $trace->uuid()
+
+The UUID of the context that was used to create the event. (If uuid tagging was
+enabled)
+
+=back
+
+=head2 DISCOURAGED HUB RELATED FIELDS
+
+These fields were not always set properly by tools. These are B<MOSTLY>
+deprecated by the L<Test2::EventFacet::Hub> facets. These fields are not
+required, and may only reflect the hub that was current when the event was
+created, which is not necessarily the same as the hub the event was sent
+through.
+
+Some tools did do a good job setting these to the correct hub, but you cannot
+always rely on that. Use the 'hubs' facet list instead.
+
+=over 4
+
+=item $hid = $trace->{hid}
+
+=item $hid = $trace->hid()
+
+The ID of the hub that was current when the event was created.
+
+=item $huuid = $trace->{huuid}
+
+=item $huuid = $trace->huuid()
+
+The UUID of the hub that was current when the event was created. (If uuid
+tagging was enabled).
+
+=item $int = $trace->{nested}
+
+=item $int = $trace->nested()
+
+How deeply nested the event is.
+
+=item $bool = $trace->{buffered}
+
+=item $bool = $trace->buffered()
+
+True if the event was buffered and not sent to the formatter independent of a
+parent (This should never be set when nested is C<0> or C<undef>).
+
+=back
+
+=head1 METHODS
+
+B<Note:> All facet frames are also methods.
+
+=over 4
+
+=item $trace->set_detail($msg)
+
+=item $msg = $trace->detail
+
+Used to get/set a custom trace message that will be used INSTEAD of
+C<< at <FILE> line <LINE> >> when calling C<< $trace->debug >>.
+
+C<detail()> is an alias to the C<details> facet field for backwards
+compatibility.
+
+=item $str = $trace->debug
+
+Typically returns the string C<< at <FILE> line <LINE> >>. If C<detail> is set
+then its value will be returned instead.
+
+=item $trace->alert($MESSAGE)
+
+This issues a warning at the frame (filename and line number where
+errors should be reported).
+
+=item $trace->throw($MESSAGE)
+
+This throws an exception at the frame (filename and line number where
+errors should be reported).
+
+=item ($package, $file, $line, $subname) = $trace->call()
+
+Get the caller details for the debug-info. This is where errors should be
+reported.
+
+=item $pkg = $trace->package
+
+Get the debug-info package.
+
+=item $file = $trace->file
+
+Get the debug-info filename.
+
+=item $line = $trace->line
+
+Get the debug-info line number.
+
+=item $subname = $trace->subname
+
+Get the debug-info subroutine name.
+
+=item $sig = trace->signature
+
+Get a signature string that identifies this trace. This is used to check if
+multiple events are related. The signature includes pid, tid, file, line
+number, and the cid.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Formatter/TAP.pm

@@ -0,0 +1,524 @@
+package Test2::Formatter::TAP;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+use Test2::Util qw/clone_io/;
+
+use Test2::Util::HashBase qw{
+    no_numbers handles _encoding _last_fh
+    -made_assertion
+};
+
+sub OUT_STD() { 0 }
+sub OUT_ERR() { 1 }
+
+BEGIN { require Test2::Formatter; our @ISA = qw(Test2::Formatter) }
+
+# Not constants because this is a method, and can be overriden
+BEGIN {
+    local $SIG{__DIE__} = 'DEFAULT';
+    local $@;
+    if (($INC{'Term/Table.pm'} && $INC{'Term/Table/Util.pm'}) || eval { require Term::Table; require Term::Table::Util; 1 }) {
+        *supports_tables = sub { 1 };
+    }
+    else {
+        *supports_tables = sub { 0 };
+    }
+}
+
+sub _autoflush {
+    my($fh) = pop;
+    my $old_fh = select $fh;
+    $| = 1;
+    select $old_fh;
+}
+
+_autoflush(\*STDOUT);
+_autoflush(\*STDERR);
+
+sub hide_buffered { 1 }
+
+sub init {
+    my $self = shift;
+
+    $self->{+HANDLES} ||= $self->_open_handles;
+    if(my $enc = delete $self->{encoding}) {
+        $self->encoding($enc);
+    }
+}
+
+sub _open_handles {
+    my $self = shift;
+
+    require Test2::API;
+    my $out = clone_io(Test2::API::test2_stdout());
+    my $err = clone_io(Test2::API::test2_stderr());
+
+    _autoflush($out);
+    _autoflush($err);
+
+    return [$out, $err];
+}
+
+sub encoding {
+    my $self = shift;
+
+    if ($] ge "5.007003" and @_) {
+        my ($enc) = @_;
+        my $handles = $self->{+HANDLES};
+
+        # https://rt.perl.org/Public/Bug/Display.html?id=31923
+        # If utf8 is requested we use ':utf8' instead of ':encoding(utf8)' in
+        # order to avoid the thread segfault.
+        if ($enc =~ m/^utf-?8$/i) {
+            binmode($_, ":utf8") for @$handles;
+        }
+        else {
+            binmode($_, ":encoding($enc)") for @$handles;
+        }
+        $self->{+_ENCODING} = $enc;
+    }
+
+    return $self->{+_ENCODING};
+}
+
+if ($^C) {
+    no warnings 'redefine';
+    *write = sub {};
+}
+sub write {
+    my ($self, $e, $num, $f) = @_;
+
+    # The most common case, a pass event with no amnesty and a normal name.
+    return if $self->print_optimal_pass($e, $num);
+
+    $f ||= $e->facet_data;
+
+    $self->encoding($f->{control}->{encoding}) if $f->{control}->{encoding};
+
+    my @tap = $self->event_tap($f, $num) or return;
+
+    $self->{+MADE_ASSERTION} = 1 if $f->{assert};
+
+    my $nesting = $f->{trace}->{nested} || 0;
+    my $handles = $self->{+HANDLES};
+    my $indent = '    ' x $nesting;
+
+    # Local is expensive! Only do it if we really need to.
+    local($\, $,) = (undef, '') if $\ || $,;
+    for my $set (@tap) {
+        no warnings 'uninitialized';
+        my ($hid, $msg) = @$set;
+        next unless $msg;
+        my $io = $handles->[$hid] or next;
+
+        print $io "\n"
+            if $ENV{HARNESS_ACTIVE}
+            && $hid == OUT_ERR
+            && $self->{+_LAST_FH} != $io
+            && $msg =~ m/^#\s*Failed( \(TODO\))? test /;
+
+        $msg =~ s/^/$indent/mg if $nesting;
+        print $io $msg;
+        $self->{+_LAST_FH} = $io;
+    }
+}
+
+sub print_optimal_pass {
+    my ($self, $e, $num) = @_;
+
+    my $type = ref($e);
+
+    # Only optimal if this is a Pass or a passing Ok
+    return unless $type eq 'Test2::Event::Pass' || ($type eq 'Test2::Event::Ok' && $e->{pass});
+
+    # Amnesty requires further processing (todo is a form of amnesty)
+    return if ($e->{amnesty} && @{$e->{amnesty}}) || defined($e->{todo});
+
+    # A name with a newline or hash symbol needs extra processing
+    return if defined($e->{name}) && (-1 != index($e->{name}, "\n") || -1 != index($e->{name}, '#'));
+
+    my $ok = 'ok';
+    $ok .= " $num" if $num && !$self->{+NO_NUMBERS};
+    $ok .= defined($e->{name}) ? " - $e->{name}\n" : "\n";
+
+    if (my $nesting = $e->{trace}->{nested}) {
+        my $indent = '    ' x $nesting;
+        $ok = "$indent$ok";
+    }
+
+    my $io = $self->{+HANDLES}->[OUT_STD];
+
+    local($\, $,) = (undef, '') if $\ || $,;
+    print $io $ok;
+    $self->{+_LAST_FH} = $io;
+
+    return 1;
+}
+
+sub event_tap {
+    my ($self, $f, $num) = @_;
+
+    my @tap;
+
+    # If this IS the first event the plan should come first
+    # (plan must be before or after assertions, not in the middle)
+    push @tap => $self->plan_tap($f) if $f->{plan} && !$self->{+MADE_ASSERTION};
+
+    # The assertion is most important, if present.
+    if ($f->{assert}) {
+        push @tap => $self->assert_tap($f, $num);
+        push @tap => $self->debug_tap($f, $num) unless $f->{assert}->{no_debug} || $f->{assert}->{pass};
+    }
+
+    # Almost as important as an assertion
+    push @tap => $self->error_tap($f) if $f->{errors};
+
+    # Now lets see the diagnostics messages
+    push @tap => $self->info_tap($f) if $f->{info};
+
+    # If this IS NOT the first event the plan should come last
+    # (plan must be before or after assertions, not in the middle)
+    push @tap => $self->plan_tap($f) if $self->{+MADE_ASSERTION} && $f->{plan};
+
+    # Bail out
+    push @tap => $self->halt_tap($f) if $f->{control}->{halt};
+
+    return @tap if @tap;
+    return @tap if $f->{control}->{halt};
+    return @tap if grep { $f->{$_} } qw/assert plan info errors/;
+
+    # Use the summary as a fallback if nothing else is usable.
+    return $self->summary_tap($f, $num);
+}
+
+sub error_tap {
+    my $self = shift;
+    my ($f) = @_;
+
+    my $IO = ($f->{amnesty} && @{$f->{amnesty}}) ? OUT_STD : OUT_ERR;
+
+    return map {
+        my $details = $_->{details};
+
+        my $msg;
+        if (ref($details)) {
+            require Data::Dumper;
+            my $dumper = Data::Dumper->new([$details])->Indent(2)->Terse(1)->Pad('# ')->Useqq(1)->Sortkeys(1);
+            chomp($msg = $dumper->Dump);
+        }
+        else {
+            chomp($msg = $details);
+            $msg =~ s/^/# /;
+            $msg =~ s/\n/\n# /g;
+        }
+
+        [$IO, "$msg\n"];
+    } @{$f->{errors}};
+}
+
+sub plan_tap {
+    my $self = shift;
+    my ($f) = @_;
+    my $plan = $f->{plan} or return;
+
+    return if $plan->{none};
+
+    if ($plan->{skip}) {
+        my $reason = $plan->{details} or return [OUT_STD, "1..0 # SKIP\n"];
+        chomp($reason);
+        return [OUT_STD, '1..0 # SKIP ' . $reason . "\n"];
+    }
+
+    return [OUT_STD, "1.." . $plan->{count} . "\n"];
+}
+
+sub no_subtest_space { 0 }
+sub assert_tap {
+    my $self = shift;
+    my ($f, $num) = @_;
+
+    my $assert = $f->{assert} or return;
+    my $pass = $assert->{pass};
+    my $name = $assert->{details};
+
+    my $ok = $pass ? 'ok' : 'not ok';
+    $ok .= " $num" if $num && !$self->{+NO_NUMBERS};
+
+    # The regex form is ~250ms, the index form is ~50ms
+    my @extra;
+    defined($name) && (
+        (index($name, "\n") != -1 && (($name, @extra) = split(/\n\r?/, $name, -1))),
+        ((index($name, "#" ) != -1  || substr($name, -1) eq '\\') && (($name =~ s|\\|\\\\|g), ($name =~ s|#|\\#|g)))
+    );
+
+    my $extra_space = @extra ? ' ' x (length($ok) + 2) : '';
+    my $extra_indent = '';
+
+    my ($directives, $reason, $is_skip);
+    if ($f->{amnesty}) {
+        my %directives;
+
+        for my $am (@{$f->{amnesty}}) {
+            next if $am->{inherited};
+            my $tag = $am->{tag} or next;
+            $is_skip = 1 if $tag eq 'skip';
+
+            $directives{$tag} ||= $am->{details};
+        }
+
+        my %seen;
+        my @order = grep { !$seen{$_}++ } sort keys %directives;
+
+        $directives = ' # ' . join ' & ' => @order;
+
+        for my $tag ('skip', @order) {
+            next unless defined($directives{$tag}) && length($directives{$tag});
+            $reason = $directives{$tag};
+            last;
+        }
+    }
+
+    $ok .= " - $name" if defined $name && !($is_skip && !$name);
+
+    my @subtap;
+    if ($f->{parent} && $f->{parent}->{buffered}) {
+        $ok .= ' {';
+
+        # In a verbose harness we indent the extra since they will appear
+        # inside the subtest braces. This helps readability. In a non-verbose
+        # harness we do not do this because it is less readable.
+        if ($ENV{HARNESS_IS_VERBOSE} || !$ENV{HARNESS_ACTIVE}) {
+            $extra_indent = "    ";
+            $extra_space = ' ';
+        }
+
+        # Render the sub-events, we use our own counter for these.
+        my $count = 0;
+        @subtap = map {
+            my $f2 = $_;
+
+            # Bump the count for any event that should bump it.
+            $count++ if $f2->{assert};
+
+            # This indents all output lines generated for the sub-events.
+            # index 0 is the filehandle, index 1 is the message we want to indent.
+            map { $_->[1] =~ s/^(.*\S.*)$/    $1/mg; $_ } $self->event_tap($f2, $count);
+        } @{$f->{parent}->{children}};
+
+        push @subtap => [OUT_STD, "}\n"];
+    }
+
+    if ($directives) {
+        $directives = ' # TODO & SKIP' if $directives eq ' # TODO & skip';
+        $ok .= $directives;
+        $ok .= " $reason" if defined($reason);
+    }
+
+    $extra_space = ' ' if $self->no_subtest_space;
+
+    my @out = ([OUT_STD, "$ok\n"]);
+    push @out => map {[OUT_STD, "${extra_indent}#${extra_space}$_\n"]} @extra if @extra;
+    push @out => @subtap;
+
+    return @out;
+}
+
+sub debug_tap {
+    my ($self, $f, $num) = @_;
+
+    # Figure out the debug info, this is typically the file name and line
+    # number, but can also be a custom message. If no trace object is provided
+    # then we have nothing useful to display.
+    my $name  = $f->{assert}->{details};
+    my $trace = $f->{trace};
+
+    my $debug = "[No trace info available]";
+    if ($trace->{details}) {
+        $debug = $trace->{details};
+    }
+    elsif ($trace->{frame}) {
+        my ($pkg, $file, $line) = @{$trace->{frame}};
+        $debug = "at $file line $line." if $file && $line;
+    }
+
+    my $amnesty = $f->{amnesty} && @{$f->{amnesty}}
+        ? ' (with amnesty)'
+        : '';
+
+    # Create the initial diagnostics. If the test has a name we put the debug
+    # info on a second line, this behavior is inherited from Test::Builder.
+    my $msg = defined($name)
+        ? qq[# Failed test${amnesty} '$name'\n# $debug\n]
+        : qq[# Failed test${amnesty} $debug\n];
+
+    my $IO = $f->{amnesty} && @{$f->{amnesty}} ? OUT_STD : OUT_ERR;
+
+    return [$IO, $msg];
+}
+
+sub halt_tap {
+    my ($self, $f) = @_;
+
+    return if $f->{trace}->{nested} && !$f->{trace}->{buffered};
+    my $details = $f->{control}->{details};
+
+    return [OUT_STD, "Bail out!\n"] unless defined($details) && length($details);
+    return [OUT_STD, "Bail out!  $details\n"];
+}
+
+sub info_tap {
+    my ($self, $f) = @_;
+
+    return map {
+        my $details = $_->{details};
+        my $table   = $_->{table};
+
+        my $IO = $_->{debug} && !($f->{amnesty} && @{$f->{amnesty}}) ? OUT_ERR : OUT_STD;
+
+        my $msg;
+        if ($table && $self->supports_tables) {
+            $msg = join "\n" => map { "# $_" } Term::Table->new(
+                header      => $table->{header},
+                rows        => $table->{rows},
+                collapse    => $table->{collapse},
+                no_collapse => $table->{no_collapse},
+                sanitize    => 1,
+                mark_tail   => 1,
+                max_width   => $self->calc_table_size($f),
+            )->render();
+        }
+        elsif (ref($details)) {
+            require Data::Dumper;
+            my $dumper = Data::Dumper->new([$details])->Indent(2)->Terse(1)->Pad('# ')->Useqq(1)->Sortkeys(1);
+            chomp($msg = $dumper->Dump);
+        }
+        else {
+            chomp($msg = $details);
+            $msg =~ s/^/# /;
+            $msg =~ s/\n/\n# /g;
+        }
+
+        [$IO, "$msg\n"];
+    } @{$f->{info}};
+}
+
+sub summary_tap {
+    my ($self, $f, $num) = @_;
+
+    return if $f->{about}->{no_display};
+
+    my $summary = $f->{about}->{details} or return;
+    chomp($summary);
+    $summary =~ s/^/# /smg;
+
+    return [OUT_STD, "$summary\n"];
+}
+
+sub calc_table_size {
+    my $self = shift;
+    my ($f) = @_;
+
+    my $term = Term::Table::Util::term_size();
+    my $nesting = 2 + (($f->{trace}->{nested} || 0) * 4); # 4 spaces per level, also '# ' prefix
+    my $total = $term - $nesting;
+
+    # Sane minimum width, any smaller and we are asking for pain
+    return 50 if $total < 50;
+
+    return $total;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Formatter::TAP - Standard TAP formatter
+
+=head1 DESCRIPTION
+
+This is what takes events and turns them into TAP.
+
+=head1 SYNOPSIS
+
+    use Test2::Formatter::TAP;
+    my $tap = Test2::Formatter::TAP->new();
+
+    # Switch to utf8
+    $tap->encoding('utf8');
+
+    $tap->write($event, $number); # Output an event
+
+=head1 METHODS
+
+=over 4
+
+=item $bool = $tap->no_numbers
+
+=item $tap->set_no_numbers($bool)
+
+Use to turn numbers on and off.
+
+=item $arrayref = $tap->handles
+
+=item $tap->set_handles(\@handles);
+
+Can be used to get/set the filehandles. Indexes are identified by the
+C<OUT_STD> and C<OUT_ERR> constants.
+
+=item $encoding = $tap->encoding
+
+=item $tap->encoding($encoding)
+
+Get or set the encoding. By default no encoding is set, the original settings
+of STDOUT and STDERR are used.
+
+This directly modifies the stored filehandles, it does not create new ones.
+
+=item $tap->write($e, $num)
+
+Write an event to the console.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=item Kent Fredric E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Tools/Tiny.pm

@@ -0,0 +1,435 @@
+package Test2::Tools::Tiny;
+use strict;
+use warnings;
+
+BEGIN {
+    if ($] lt "5.008") {
+        require Test::Builder::IO::Scalar;
+    }
+}
+
+use Scalar::Util qw/blessed/;
+
+use Test2::Util qw/try/;
+use Test2::API qw/context run_subtest test2_stack/;
+
+use Test2::Hub::Interceptor();
+use Test2::Hub::Interceptor::Terminator();
+
+our $VERSION = '1.302162';
+
+BEGIN { require Exporter; our @ISA = qw(Exporter) }
+our @EXPORT = qw{
+    ok is isnt like unlike is_deeply diag note skip_all todo plan done_testing
+    warnings exception tests capture
+};
+
+sub ok($;$@) {
+    my ($bool, $name, @diag) = @_;
+    my $ctx = context();
+
+    return $ctx->pass_and_release($name) if $bool;
+    return $ctx->fail_and_release($name, @diag);
+}
+
+sub is($$;$@) {
+    my ($got, $want, $name, @diag) = @_;
+    my $ctx = context();
+
+    my $bool;
+    if (defined($got) && defined($want)) {
+        $bool = "$got" eq "$want";
+    }
+    elsif (defined($got) xor defined($want)) {
+        $bool = 0;
+    }
+    else {    # Both are undef
+        $bool = 1;
+    }
+
+    return $ctx->pass_and_release($name) if $bool;
+
+    $got  = '*NOT DEFINED*' unless defined $got;
+    $want = '*NOT DEFINED*' unless defined $want;
+    unshift @diag => (
+        "GOT:      $got",
+        "EXPECTED: $want",
+    );
+
+    return $ctx->fail_and_release($name, @diag);
+}
+
+sub isnt($$;$@) {
+    my ($got, $want, $name, @diag) = @_;
+    my $ctx = context();
+
+    my $bool;
+    if (defined($got) && defined($want)) {
+        $bool = "$got" ne "$want";
+    }
+    elsif (defined($got) xor defined($want)) {
+        $bool = 1;
+    }
+    else {    # Both are undef
+        $bool = 0;
+    }
+
+    return $ctx->pass_and_release($name) if $bool;
+
+    unshift @diag => "Strings are the same (they should not be)"
+        unless $bool;
+
+    return $ctx->fail_and_release($name, @diag);
+}
+
+sub like($$;$@) {
+    my ($thing, $pattern, $name, @diag) = @_;
+    my $ctx = context();
+
+    my $bool;
+    if (defined($thing)) {
+        $bool = "$thing" =~ $pattern;
+        unshift @diag => (
+            "Value: $thing",
+            "Does not match: $pattern"
+        ) unless $bool;
+    }
+    else {
+        $bool = 0;
+        unshift @diag => "Got an undefined value.";
+    }
+
+    return $ctx->pass_and_release($name) if $bool;
+    return $ctx->fail_and_release($name, @diag);
+}
+
+sub unlike($$;$@) {
+    my ($thing, $pattern, $name, @diag) = @_;
+    my $ctx = context();
+
+    my $bool;
+    if (defined($thing)) {
+        $bool = "$thing" !~ $pattern;
+        unshift @diag => (
+            "Unexpected pattern match (it should not match)",
+            "Value:   $thing",
+            "Matches: $pattern"
+        ) unless $bool;
+    }
+    else {
+        $bool = 0;
+        unshift @diag => "Got an undefined value.";
+    }
+
+    return $ctx->pass_and_release($name) if $bool;
+    return $ctx->fail_and_release($name, @diag);
+}
+
+sub is_deeply($$;$@) {
+    my ($got, $want, $name, @diag) = @_;
+    my $ctx = context();
+
+    no warnings 'once';
+    require Data::Dumper;
+
+    # Otherwise numbers might be unquoted
+    local $Data::Dumper::Useperl  = 1;
+
+    local $Data::Dumper::Sortkeys = 1;
+    local $Data::Dumper::Deparse  = 1;
+    local $Data::Dumper::Freezer  = 'XXX';
+    local *UNIVERSAL::XXX         = sub {
+        my ($thing) = @_;
+        if (ref($thing)) {
+            $thing = {%$thing}  if "$thing" =~ m/=HASH/;
+            $thing = [@$thing]  if "$thing" =~ m/=ARRAY/;
+            $thing = \"$$thing" if "$thing" =~ m/=SCALAR/;
+        }
+        $_[0] = $thing;
+    };
+
+    my $g = Data::Dumper::Dumper($got);
+    my $w = Data::Dumper::Dumper($want);
+
+    my $bool = $g eq $w;
+
+    return $ctx->pass_and_release($name) if $bool;
+    return $ctx->fail_and_release($name, $g, $w, @diag);
+}
+
+sub diag {
+    my $ctx = context();
+    $ctx->diag(join '', @_);
+    $ctx->release;
+}
+
+sub note {
+    my $ctx = context();
+    $ctx->note(join '', @_);
+    $ctx->release;
+}
+
+sub skip_all {
+    my ($reason) = @_;
+    my $ctx = context();
+    $ctx->plan(0, SKIP => $reason);
+    $ctx->release if $ctx;
+}
+
+sub todo {
+    my ($reason, $sub) = @_;
+    my $ctx = context();
+
+    # This code is mostly copied from Test2::Todo in the Test2-Suite
+    # distribution.
+    my $hub    = test2_stack->top;
+    my $filter = $hub->pre_filter(
+        sub {
+            my ($active_hub, $event) = @_;
+            if ($active_hub == $hub) {
+                $event->set_todo($reason) if $event->can('set_todo');
+                $event->add_amnesty({tag => 'TODO', details => $reason});
+            }
+            else {
+                $event->add_amnesty({tag => 'TODO', details => $reason, inherited => 1});
+            }
+            return $event;
+        },
+        inherit => 1,
+        todo    => $reason,
+    );
+    $sub->();
+    $hub->pre_unfilter($filter);
+
+    $ctx->release if $ctx;
+}
+
+sub plan {
+    my ($max) = @_;
+    my $ctx = context();
+    $ctx->plan($max);
+    $ctx->release;
+}
+
+sub done_testing {
+    my $ctx = context();
+    $ctx->done_testing;
+    $ctx->release;
+}
+
+sub warnings(&) {
+    my $code = shift;
+    my @warnings;
+    local $SIG{__WARN__} = sub { push @warnings => @_ };
+    $code->();
+    return \@warnings;
+}
+
+sub exception(&) {
+    my $code = shift;
+    local ($@, $!, $SIG{__DIE__});
+    my $ok = eval { $code->(); 1 };
+    my $error = $@ || 'SQUASHED ERROR';
+    return $ok ? undef : $error;
+}
+
+sub tests {
+    my ($name, $code) = @_;
+    my $ctx = context();
+
+    my $be = caller->can('before_each');
+
+    $be->($name) if $be;
+
+    my $bool = run_subtest($name, $code, 1);
+
+    $ctx->release;
+
+    return $bool;
+}
+
+sub capture(&) {
+    my $code = shift;
+
+    my ($err, $out) = ("", "");
+
+    my $handles = test2_stack->top->format->handles;
+    my ($ok, $e);
+    {
+        my ($out_fh, $err_fh);
+
+        ($ok, $e) = try {
+          # Scalar refs as filehandles were added in 5.8.
+          if ($] ge "5.008") {
+            open($out_fh, '>', \$out) or die "Failed to open a temporary STDOUT: $!";
+            open($err_fh, '>', \$err) or die "Failed to open a temporary STDERR: $!";
+          }
+          # Emulate scalar ref filehandles with a tie.
+          else {
+            $out_fh = Test::Builder::IO::Scalar->new(\$out) or die "Failed to open a temporary STDOUT";
+            $err_fh = Test::Builder::IO::Scalar->new(\$err) or die "Failed to open a temporary STDERR";
+          }
+
+            test2_stack->top->format->set_handles([$out_fh, $err_fh, $out_fh]);
+
+            $code->();
+        };
+    }
+    test2_stack->top->format->set_handles($handles);
+
+    die $e unless $ok;
+
+    $err =~ s/ $/_/mg;
+    $out =~ s/ $/_/mg;
+
+    return {
+        STDOUT => $out,
+        STDERR => $err,
+    };
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Tools::Tiny - Tiny set of tools for unfortunate souls who cannot use
+L<Test2::Suite>.
+
+=head1 DESCRIPTION
+
+You should really look at L<Test2::Suite>. This package is some very basic
+essential tools implemented using L<Test2>. This exists only so that L<Test2>
+and other tools required by L<Test2::Suite> can be tested. This is the package
+L<Test2> uses to test itself.
+
+=head1 USE Test2::Suite INSTEAD
+
+Use L<Test2::Suite> if at all possible.
+
+=head1 EXPORTS
+
+=over 4
+
+=item ok($bool, $name)
+
+=item ok($bool, $name, @diag)
+
+Run a simple assertion.
+
+=item is($got, $want, $name)
+
+=item is($got, $want, $name, @diag)
+
+Assert that 2 strings are the same.
+
+=item isnt($got, $do_not_want, $name)
+
+=item isnt($got, $do_not_want, $name, @diag)
+
+Assert that 2 strings are not the same.
+
+=item like($got, $regex, $name)
+
+=item like($got, $regex, $name, @diag)
+
+Check that the input string matches the regex.
+
+=item unlike($got, $regex, $name)
+
+=item unlike($got, $regex, $name, @diag)
+
+Check that the input string does not match the regex.
+
+=item is_deeply($got, $want, $name)
+
+=item is_deeply($got, $want, $name, @diag)
+
+Check 2 data structures. Please note that this is a I<DUMB> implementation that
+compares the output of L<Data::Dumper> against both structures.
+
+=item diag($msg)
+
+Issue a diagnostics message to STDERR.
+
+=item note($msg)
+
+Issue a diagnostics message to STDOUT.
+
+=item skip_all($reason)
+
+Skip all tests.
+
+=item todo $reason => sub { ... }
+
+Run a block in TODO mode.
+
+=item plan($count)
+
+Set the plan.
+
+=item done_testing()
+
+Set the plan to the current test count.
+
+=item $warnings = warnings { ... }
+
+Capture an arrayref of warnings from the block.
+
+=item $exception = exception { ... }
+
+Capture an exception.
+
+=item tests $name => sub { ... }
+
+Run a subtest.
+
+=item $output = capture { ... }
+
+Capture STDOUT and STDERR output.
+
+Result looks like this:
+
+    {
+        STDOUT => "...",
+        STDERR => "...",
+    }
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+F<http://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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

my_container_sandbox/usr/share/perl/5.30.0/Test2/Util/HashBase.pm

@@ -0,0 +1,435 @@
+package Test2::Util::HashBase;
+use strict;
+use warnings;
+
+our $VERSION = '1.302162';
+
+#################################################################
+#                                                               #
+#  This is a generated file! Do not modify this file directly!  #
+#  Use hashbase_inc.pl script to regenerate this file.          #
+#  The script is part of the Object::HashBase distribution.     #
+#  Note: You can modify the version number above this comment   #
+#  if needed, that is fine.                                     #
+#                                                               #
+#################################################################
+
+{
+    no warnings 'once';
+    $Test2::Util::HashBase::HB_VERSION = '0.006';
+    *Test2::Util::HashBase::ATTR_SUBS = \%Object::HashBase::ATTR_SUBS;
+    *Test2::Util::HashBase::ATTR_LIST = \%Object::HashBase::ATTR_LIST;
+    *Test2::Util::HashBase::VERSION   = \%Object::HashBase::VERSION;
+    *Test2::Util::HashBase::CAN_CACHE = \%Object::HashBase::CAN_CACHE;
+}
+
+
+require Carp;
+{
+    no warnings 'once';
+    $Carp::Internal{+__PACKAGE__} = 1;
+}
+
+BEGIN {
+    # these are not strictly equivalent, but for out use we don't care
+    # about order
+    *_isa = ($] >= 5.010 && require mro) ? \&mro::get_linear_isa : sub {
+        no strict 'refs';
+        my @packages = ($_[0]);
+        my %seen;
+        for my $package (@packages) {
+            push @packages, grep !$seen{$_}++, @{"$package\::ISA"};
+        }
+        return \@packages;
+    }
+}
+
+my %STRIP = (
+    '^' => 1,
+    '-' => 1,
+);
+
+sub import {
+    my $class = shift;
+    my $into  = caller;
+
+    # Make sure we list the OLDEST version used to create this class.
+    my $ver = $Test2::Util::HashBase::HB_VERSION || $Test2::Util::HashBase::VERSION;
+    $Test2::Util::HashBase::VERSION{$into} = $ver if !$Test2::Util::HashBase::VERSION{$into} || $Test2::Util::HashBase::VERSION{$into} > $ver;
+
+    my $isa = _isa($into);
+    my $attr_list = $Test2::Util::HashBase::ATTR_LIST{$into} ||= [];
+    my $attr_subs = $Test2::Util::HashBase::ATTR_SUBS{$into} ||= {};
+
+    my %subs = (
+        ($into->can('new') ? () : (new => \&_new)),
+        (map %{$Test2::Util::HashBase::ATTR_SUBS{$_} || {}}, @{$isa}[1 .. $#$isa]),
+        (
+            map {
+                my $p = substr($_, 0, 1);
+                my $x = $_;
+                substr($x, 0, 1) = '' if $STRIP{$p};
+                push @$attr_list => $x;
+                my ($sub, $attr) = (uc $x, $x);
+                $sub => ($attr_subs->{$sub} = sub() { $attr }),
+                    $attr => sub { $_[0]->{$attr} },
+                      $p eq '-' ? ("set_$attr" => sub { Carp::croak("'$attr' is read-only") })
+                    : $p eq '^' ? ("set_$attr" => sub { Carp::carp("set_$attr() is deprecated"); $_[0]->{$attr} = $_[1] })
+                    : ("set_$attr" => sub { $_[0]->{$attr} = $_[1] }),
+            } @_
+        ),
+    );
+
+    no strict 'refs';
+    *{"$into\::$_"} = $subs{$_} for keys %subs;
+}
+
+sub attr_list {
+    my $class = shift;
+
+    my $isa = _isa($class);
+
+    my %seen;
+    my @list = grep { !$seen{$_}++ } map {
+        my @out;
+
+        if (0.004 > ($Test2::Util::HashBase::VERSION{$_} || 0)) {
+            Carp::carp("$_ uses an inlined version of Test2::Util::HashBase too old to support attr_list()");
+        }
+        else {
+            my $list = $Test2::Util::HashBase::ATTR_LIST{$_};
+            @out = $list ? @$list : ()
+        }
+
+        @out;
+    } reverse @$isa;
+
+    return @list;
+}
+
+sub _new {
+    my $class = shift;
+
+    my $self;
+
+    if (@_ == 1) {
+        my $arg = shift;
+        my $type = ref($arg);
+
+        if ($type eq 'HASH') {
+            $self = bless({%$arg}, $class)
+        }
+        else {
+            Carp::croak("Not sure what to do with '$type' in $class constructor")
+                unless $type eq 'ARRAY';
+
+            my %proto;
+            my @attributes = attr_list($class);
+            while (@$arg) {
+                my $val = shift @$arg;
+                my $key = shift @attributes or Carp::croak("Too many arguments for $class constructor");
+                $proto{$key} = $val;
+            }
+
+            $self = bless(\%proto, $class);
+        }
+    }
+    else {
+        $self = bless({@_}, $class);
+    }
+
+    $Test2::Util::HashBase::CAN_CACHE{$class} = $self->can('init')
+        unless exists $Test2::Util::HashBase::CAN_CACHE{$class};
+
+    $self->init if $Test2::Util::HashBase::CAN_CACHE{$class};
+
+    $self;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Util::HashBase - Build hash based classes.
+
+=head1 SYNOPSIS
+
+A class:
+
+    package My::Class;
+    use strict;
+    use warnings;
+
+    # Generate 3 accessors
+    use Test2::Util::HashBase qw/foo -bar ^baz/;
+
+    # Chance to initialize defaults
+    sub init {
+        my $self = shift;    # No other args
+        $self->{+FOO} ||= "foo";
+        $self->{+BAR} ||= "bar";
+        $self->{+BAZ} ||= "baz";
+    }
+
+    sub print {
+        print join ", " => map { $self->{$_} } FOO, BAR, BAZ;
+    }
+
+Subclass it
+
+    package My::Subclass;
+    use strict;
+    use warnings;
+
+    # Note, you should subclass before loading HashBase.
+    use base 'My::Class';
+    use Test2::Util::HashBase qw/bat/;
+
+    sub init {
+        my $self = shift;
+
+        # We get the constants from the base class for free.
+        $self->{+FOO} ||= 'SubFoo';
+        $self->{+BAT} ||= 'bat';
+
+        $self->SUPER::init();
+    }
+
+use it:
+
+    package main;
+    use strict;
+    use warnings;
+    use My::Class;
+
+    # These are all functionally identical
+    my $one   = My::Class->new(foo => 'MyFoo', bar => 'MyBar');
+    my $two   = My::Class->new({foo => 'MyFoo', bar => 'MyBar'});
+    my $three = My::Class->new(['MyFoo', 'MyBar']);
+
+    # Accessors!
+    my $foo = $one->foo;    # 'MyFoo'
+    my $bar = $one->bar;    # 'MyBar'
+    my $baz = $one->baz;    # Defaulted to: 'baz'
+
+    # Setters!
+    $one->set_foo('A Foo');
+
+    #'-bar' means read-only, so the setter will throw an exception (but is defined).
+    $one->set_bar('A bar');
+
+    # '^baz' means deprecated setter, this will warn about the setter being
+    # deprecated.
+    $one->set_baz('A Baz');
+
+    $one->{+FOO} = 'xxx';
+
+=head1 DESCRIPTION
+
+This package is used to generate classes based on hashrefs. Using this class
+will give you a C<new()> method, as well as generating accessors you request.
+Generated accessors will be getters, C<set_ACCESSOR> setters will also be
+generated for you. You also get constants for each accessor (all caps) which
+return the key into the hash for that accessor. Single inheritance is also
+supported.
+
+=head1 THIS IS A BUNDLED COPY OF HASHBASE
+
+This is a bundled copy of L<Object::HashBase>. This file was generated using
+the
+C</home/exodist/perl5/perlbrew/perls/main/bin/hashbase_inc.pl>
+script.
+
+=head1 METHODS
+
+=head2 PROVIDED BY HASH BASE
+
+=over 4
+
+=item $it = $class->new(%PAIRS)
+
+=item $it = $class->new(\%PAIRS)
+
+=item $it = $class->new(\@ORDERED_VALUES)
+
+Create a new instance.
+
+HashBase will not export C<new()> if there is already a C<new()> method in your
+packages inheritance chain.
+
+B<If you do not want this method you can define your own> you just have to
+declare it before loading L<Test2::Util::HashBase>.
+
+    package My::Package;
+
+    # predeclare new() so that HashBase does not give us one.
+    sub new;
+
+    use Test2::Util::HashBase qw/foo bar baz/;
+
+    # Now we define our own new method.
+    sub new { ... }
+
+This makes it so that HashBase sees that you have your own C<new()> method.
+Alternatively you can define the method before loading HashBase instead of just
+declaring it, but that scatters your use statements.
+
+The most common way to create an object is to pass in key/value pairs where
+each key is an attribute and each value is what you want assigned to that
+attribute. No checking is done to verify the attributes or values are valid,
+you may do that in C<init()> if desired.
+
+If you would like, you can pass in a hashref instead of pairs. When you do so
+the hashref will be copied, and the copy will be returned blessed as an object.
+There is no way to ask HashBase to bless a specific hashref.
+
+In some cases an object may only have 1 or 2 attributes, in which case a
+hashref may be too verbose for your liking. In these cases you can pass in an
+arrayref with only values. The values will be assigned to attributes in the
+order the attributes were listed. When there is inheritance involved the
+attributes from parent classes will come before subclasses.
+
+=back
+
+=head2 HOOKS
+
+=over 4
+
+=item $self->init()
+
+This gives you the chance to set some default values to your fields. The only
+argument is C<$self> with its indexes already set from the constructor.
+
+B<Note:> Test2::Util::HashBase checks for an init using C<< $class->can('init') >>
+during construction. It DOES NOT call C<can()> on the created object. Also note
+that the result of the check is cached, it is only ever checked once, the first
+time an instance of your class is created. This means that adding an C<init()>
+method AFTER the first construction will result in it being ignored.
+
+=back
+
+=head1 ACCESSORS
+
+=head2 READ/WRITE
+
+To generate accessors you list them when using the module:
+
+    use Test2::Util::HashBase qw/foo/;
+
+This will generate the following subs in your namespace:
+
+=over 4
+
+=item foo()
+
+Getter, used to get the value of the C<foo> field.
+
+=item set_foo()
+
+Setter, used to set the value of the C<foo> field.
+
+=item FOO()
+
+Constant, returns the field C<foo>'s key into the class hashref. Subclasses will
+also get this function as a constant, not simply a method, that means it is
+copied into the subclass namespace.
+
+The main reason for using these constants is to help avoid spelling mistakes
+and similar typos. It will not help you if you forget to prefix the '+' though.
+
+=back
+
+=head2 READ ONLY
+
+    use Test2::Util::HashBase qw/-foo/;
+
+=over 4
+
+=item set_foo()
+
+Throws an exception telling you the attribute is read-only. This is exported to
+override any active setters for the attribute in a parent class.
+
+=back
+
+=head2 DEPRECATED SETTER
+
+    use Test2::Util::HashBase qw/^foo/;
+
+=over 4
+
+=item set_foo()
+
+This will set the value, but it will also warn you that the method is
+deprecated.
+
+=back
+
+=head1 SUBCLASSING
+
+You can subclass an existing HashBase class.
+
+    use base 'Another::HashBase::Class';
+    use Test2::Util::HashBase qw/foo bar baz/;
+
+The base class is added to C<@ISA> for you, and all constants from base classes
+are added to subclasses automatically.
+
+=head1 GETTING A LIST OF ATTRIBUTES FOR A CLASS
+
+Test2::Util::HashBase provides a function for retrieving a list of attributes for an
+Test2::Util::HashBase class.
+
+=over 4
+
+=item @list = Test2::Util::HashBase::attr_list($class)
+
+=item @list = $class->Test2::Util::HashBase::attr_list()
+
+Either form above will work. This will return a list of attributes defined on
+the object. This list is returned in the attribute definition order, parent
+class attributes are listed before subclass attributes. Duplicate attributes
+will be removed before the list is returned.
+
+B<Note:> This list is used in the C<< $class->new(\@ARRAY) >> constructor to
+determine the attribute to which each value will be paired.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for HashBase can be found at
+F<http://github.com/Test-More/HashBase/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>[email protected]<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2019 Chad Granum E<lt>[email protected]<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