Add files using upload-large-folder tool

7zip/History.txt

@@ -0,0 +1,205 @@
+HISTORY of the 7-Zip
+--------------------
+
+This file contains information about changes for latest versions of 7-Zip.
+The full changelog file can be downloaded here:
+https://7-zip.org/history.txt
+
+26.01          2026-04-27
+-------------------------
+- linux version of 7-Zip can use huge pages (2 MB pages). It can increase compression
+  speed for 10% for 7z/xz/LZMA/LZMA2 compression.
+- new -spo[d|c|r] switch specifies the path generation mode for the output directory
+  for archive extraction. The output directory path is generated from the path specified
+  in the -o{dir_path} switch and the name of the archive being unpacked.
+    -spod : for Linux/Posix/macOS: -o{dir_path} specifies the direct path to the output directory.
+            The asterisk (*) character in {dir_path} will not be replaced by the archive name.
+    -spoc : 7-Zip will concatenate the path specified in -o{dir_path} with the archive name
+            to form the final path to the output directory.
+    -spor : 7-Zip will replace asterisk (*) character in the path specified in the -o{dir_path}
+            with the archive name. This is the default option.
+- some bugs were fixed.
+
+
+26.00          2026-02-12
+-------------------------
+- improved code for ZIP, CPIO, RAR, UFD, QCOW, Compound.
+- 7-Zip File Manager: improved sorting order of the file list. It uses file name as secondary sorting key.
+- 7-Zip File Manager: improved Benchmark to support systems with more than 64 CPU threads.
+- the bug was fixed: 7-Zip could not correctly extract TAR archives containing sparse files.
+- some bugs were fixed.
+
+
+25.01          2025-08-03
+-------------------------
+- CVE-2025-55188 : The code for handling symbolic links has been changed
+  to provide greater security when extracting files from archives.
+  Command line switch -snld20 can be used to bypass default security
+  checks when creating symbolic links.
+
+
+25.00          2025-07-05
+-------------------------
+- 7-Zip for Windows can now use more than 64 CPU threads for compression
+  to zip/7z/xz archives and for the 7-Zip benchmark.
+  If there are more than one processor group in Windows (on systems with more than
+  64 cpu threads), 7-Zip distributes running CPU threads across different processor groups.
+- bzip2 compression speed was increased by 15-40%.
+- deflate (zip/gz) compression speed was increased by 1-3%.
+- improved support for zip, cpio and fat archives.
+- fixed some bugs.
+- CVE-2025-11001 and CVE-2025-11002 : A vulnerability was fixed for symbolic links processing,
+  when extracting files from archives.
+- the bug was fixed : CVE-2025-53816 : 7-Zip could work incorrectly for some incorrect RAR archives.
+- the bug was fixed : CVE-2025-53817 : 7-Zip could crash for some incorrect COM (Compound File) archives.
+
+
+24.09          2024-11-29
+-------------------------
+- The default dictionary size values for LZMA/LZMA2 compression methods were increased:
+         dictionary size   compression level
+  v24.08  v24.09  v24.09
+          32-bit  64-bit
+    8 MB   16 MB   16 MB   -mx4
+   16 MB   32 MB   32 MB   -mx5 : Normal
+   32 MB   64 MB   64 MB   -mx6
+   32 MB   64 MB  128 MB   -mx7 : Maximum
+   64 MB   64 MB  256 MB   -mx8
+   64 MB   64 MB  256 MB   -mx9 : Ultra
+  The default dictionary size values for 32-bit versions of LZMA/LZMA2 don't exceed 64 MB.
+- 7-Zip now can calculate the following hash checksums: SHA-512, SHA-384, SHA3-256 and MD5.
+- APM and HFS support was improved.
+- If an archive update operation uses a temporary archive folder and
+  the archive is moved to the destination folder, 7-Zip shows the progress of moving
+  the archive file, as this operation can take a long time if the archive is large.
+- The bug was fixed: 7-Zip File Manager didn't propagate Zone.Identifier stream
+  for extracted files from nested archives (if there is open archive inside another open archive).
+- Some bugs were fixed.
+
+
+24.08          2024-08-11
+-------------------------
+- The bug in 7-Zip 24.00-24.07 was fixed:
+  For creating a zip archive: 7-Zip could write extra zero bytes after the end of the archive,
+  if a file included to archive cannot be compressed to a size smaller than original.
+  The created zip archive is correct except for the useless zero bytes after the end of the archive.
+  When unpacking such a zip archive, 7-Zip displays a warning:
+    "WARNING: There are data after the end of archive".
+- The bug was fixed: there was a leak of GDI objects (internal resources in Windows)
+  in "Confirm File Replace" window, causing problems after 1600 displays of "Confirm File Replace"
+  window from same running 7-Zip process.
+- Some optimizations for displaying file icons in 7-Zip File Manager and in "Confirm File Replace" window.
+- Some bugs were fixed. CVE-2024-11612.
+
+
+24.07          2024-06-19
+-------------------------
+- The bug was fixed: 7-Zip could crash for some incorrect ZSTD archives (CVE-2024-11477).
+
+
+24.06          2024-05-26
+-------------------------
+- The bug was fixed: 7-Zip could not unpack some ZSTD archives.
+
+
+24.05          2024-05-14
+-------------------------
+- New switch -myv={MMNN} to set decoder compatibility version for 7z archive creating.
+  {MMNN} is 4-digit number that represents the version of 7-Zip without a dot.
+  If -myv={MMNN} switch is specified, 7-Zip will only use compression methods that can
+  be decoded by the specified version {MMNN} of 7-Zip and newer versions.
+  If -myv={MMNN} switch is not specified, -myv=2300 is used, and 7-Zip will only
+  use compression methods that can be decoded by 7-Zip 23.00 and newer versions.
+- New switch -myfa={FilterID} to    allow 7-Zip to use the specified filter method for 7z archive creating.
+- New switch -myfd={FilterID} to disallow 7-Zip to use the specified filter method for 7z archive creating.
+- Some bugs were fixed.
+
+
+24.04          2024-04-05
+-------------------------
+- New menu item in 7-Zip File Manager: "Tools / Delete Temporary Files...".
+  This menu item opens a window showing temporary folders and files
+  created by 7-Zip in the user's "Temp" folder on a Windows system.
+  In this window, the user can delete temporary files.
+
+
+24.03          2024-03-23
+-------------------------
+- 7-Zip now can use new RISCV filter for compression to 7z and xz archives.
+  RISCV filter can increase compression ratio for data containing executable
+  files compiled for RISC-V architecture.
+- The speed for LZMA and LZMA2 decompression in ARM64 version for Windows
+  was increased by 20%-60%.
+- 7-Zip GUI and 7-Zip File Manager can ask user permission to unpack RAR archives that
+  require big amount of memory, if the dictionary size in RAR archive is larger than 4 GB.
+- new switch -smemx{size}g : to set allowed memory usage limit for RAR archive unpacking.
+  RAR archives can use dictionary up 64 GB. Default allowed limit for RAR unpacking is 4 GB.
+- 7zg.exe (7-Zip GUI): -y switch disables user requests and messages.
+- 7-Zip shows hash methods XXH64 and BLAKE2sp in context menu.
+- -slmu switch : to show timestamps as UTC instead of LOCAL TIME.
+- -slsl switch : in console 7-Zip for Windows : to show file paths with
+  linux path separator slash '/' instead of backslash separator '\'.
+- 7-Zip supports .sha256 files that use backslash path separator '\'.
+- Some bugs were fixed.
+
+
+24.01          2024-01-31
+-------------------------
+- 7-Zip now can unpack ZSTD archives (.zst filename extension).
+- 7-Zip now can unpack ZIP, SquashFS and RPM archives that use ZSTD compression method.
+- 7-Zip now supports fast hash algorithm XXH64 that is used in ZSTD.
+- 7-Zip now can unpack RAR archives (that use larger than 4 GB dictionary) created by new WinRAR 7.00.
+- 7-Zip now can unpack DMG archives that use XZ (ULMO/LZMA) compression method.
+- 7-Zip now can unpack NTFS images with cluster size larger than 64 KB.
+- 7-Zip now can unpack MBR and GPT images with 4 KB sectors.
+- Speed optimizations for archive unpacking: rar, cab, wim, zip, gz.
+- Speed optimizations for hash caclulation: CRC-32, CRC-64, BLAKE2sp.
+- The bug was fixed: 7-Zip for Linux could fail for multivolume creation in some cases.
+- Some bugs were fixed.
+
+
+23.01          2023-06-20
+-------------------------
+- The page "Language" in 7-Zip's menu Tools/Options now shows information
+  about selected translation, including the number of translated lines.
+- Some bugs were fixed.
+
+
+23.00          2023-05-07
+-------------------------
+- 7-Zip now can use new ARM64 filter for compression to 7z and xz archives.
+  ARM64 filter can increase compression ratio for data containing executable
+  files compiled for ARM64 (AArch64) architecture.
+  Also 7-Zip now parses executable files (that have exe and dll filename extensions)
+  before compressing, and it selects appropriate filter for each parsed file:
+    - BCJ or BCJ2 filter for x86 executable files,
+    - ARM64 filter for ARM64 executable files.
+  Previous versions by default used x86 filter BCJ or BCJ2 for all exe/dll files.
+- Default section size for BCJ2 filter was changed from 64 MiB to 240 MiB.
+  It can increase compression ratio for executable files larger than 64 MiB.
+- UDF: support was improved.
+- cpio: support for hard links.
+- Some changes and optimizations in WIM creation code.
+- When new 7-Zip creates multivolume archive, 7-Zip keeps in open state
+  only volumes that still can be changed. Previous versions kept all volumes
+  in open state until the end of the archive creation.
+- 7-Zip for Linux and macOS now can reduce the number of simultaneously open files,
+  when 7-Zip opens, extracts or creates multivolume archive. It allows to avoid
+  the failures for cases with big number of volumes, bacause there is a limitation
+  for number of open files allowed for a single program in Linux and macOS.
+- There are optimizations in code for 7-Zip's context menu in Explorer:
+  the speed of preparing of the menu showing was improved for cases when big number of
+  files were selected by external program for context menu that contains 7-Zip menu commands.
+- There are changes in code for the drag-and-drop operations to and from 7-Zip File Manager.
+  And the drag-and-drop operation with right button of mouse now is supported for some cases.
+- The bugs were fixed:
+  - ZIP archives: if multithreaded zip compression was performed with more than one
+      file to stdout stream (-so switch), 7-Zip didn't write "data descriptor" for some files.
+  - ext4 archives: 7-Zip couldn't correctly extract symbolic link to directory from ext4 archives.
+  - HFS and APFS archives: 7-Zip incorrectly decoded uncompressed blocks (64 KiB) in compressed forks.
+  - HFS : zlib without Adler supported
+  - Some another bugs were fixed.
+
+
+==
+End of document

7zip/License.txt

@@ -0,0 +1,146 @@
+  7-Zip
+  ~~~~~
+  License for use and distribution
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  7-Zip Copyright (C) 1999-2026 Igor Pavlov.
+
+  The licenses for files are:
+
+    - 7z.dll:
+         - The "GNU LGPL" as main license for most of the code
+         - The "GNU LGPL" with "unRAR license restriction" for some code
+         - The "BSD 3-clause License" for some code
+         - The "BSD 2-clause License" for some code
+    - All other files: the "GNU LGPL".
+
+  Redistributions in binary form must reproduce related license information from this file.
+
+  Note:
+    You can use 7-Zip on any computer, including a computer in a commercial
+    organization. You don't need to register or pay for 7-Zip.
+
+
+GNU LGPL information
+--------------------
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You can receive a copy of the GNU Lesser General Public License from
+    http://www.gnu.org/
+
+
+
+
+BSD 3-clause License in 7-Zip code
+----------------------------------
+
+  The "BSD 3-clause License" is used for the following code in 7z.dll
+    1) LZFSE data decompression.
+       That code was derived from the code in the "LZFSE compression library" developed by Apple Inc,
+       that also uses the "BSD 3-clause License".
+    2) ZSTD data decompression.
+       that code was developed using original zstd decoder code as reference code.
+       The original zstd decoder code was developed by Facebook Inc,
+       that also uses the "BSD 3-clause License".
+
+  Copyright (c) 2015-2016, Apple Inc. All rights reserved.
+  Copyright (c) Facebook, Inc. All rights reserved.
+  Copyright (c) 2023-2026 Igor Pavlov.
+
+Text of the "BSD 3-clause License"
+----------------------------------
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may
+   be used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---
+
+
+
+
+BSD 2-clause License in 7-Zip code
+----------------------------------
+
+  The "BSD 2-clause License" is used for the XXH64 code in 7-Zip.
+
+  XXH64 code in 7-Zip was derived from the original XXH64 code developed by Yann Collet.
+
+  Copyright (c) 2012-2021 Yann Collet.
+  Copyright (c) 2023-2026 Igor Pavlov.
+
+Text of the "BSD 2-clause License"
+----------------------------------
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+---
+
+
+
+
+unRAR license restriction
+-------------------------
+
+The decompression engine for RAR archives was developed using source
+code of unRAR program.
+All copyrights to original unRAR code are owned by Alexander Roshal.
+
+The license for original unRAR code has the following restriction:
+
+  The unRAR sources cannot be used to re-create the RAR compression algorithm,
+  which is proprietary. Distribution of modified unRAR sources in separate form
+  or as a part of other software is permitted, provided that it is clearly
+  stated in the documentation and source comments that the code may
+  not be used to develop a RAR (WinRAR) compatible archiver.
+
+--

7zip/descript.ion

@@ -0,0 +1,14 @@
+7-zip.chm 7-Zip Help
+7-Zip.dll 7-Zip Plugin
+7-Zip32.dll 7-Zip Plugin 32-bit
+7z.dll 7-Zip Engine
+7z.exe 7-Zip Console 
+7z.sfx 7-Zip GUI SFX
+7zCon.sfx 7-Zip Console SFX
+7zFM.exe 7-Zip File Manager
+7zg.exe 7-Zip GUI
+descript.ion 7-Zip File Descriptions
+history.txt 7-Zip History
+Lang 7-Zip Translations
+license.txt 7-Zip License
+readme.txt 7-Zip Overview

7zip/readme.txt

@@ -0,0 +1,51 @@
+7-Zip 26.01
+-----------
+
+7-Zip is a file archiver for Windows.
+
+7-Zip Copyright (C) 1999-2026 Igor Pavlov.
+
+The main features of 7-Zip:
+
+  - High compression ratio in the new 7z format
+  - Supported formats:
+     - Packing / unpacking: 7z, XZ, BZIP2, GZIP, TAR, ZIP and WIM.
+     - Unpacking only: APFS, AR, ARJ, Base64, CAB, CHM, CPIO, CramFS, DMG, EXT, FAT, GPT, HFS,
+                       IHEX, ISO, LZH, LZMA, MBR, MSI, NSIS, NTFS, QCOW2, RAR,
+                       RPM, SquashFS, UDF, UEFI, VDI, VHD, VHDX, VMDK, XAR, Z and ZSTD.
+  - Fast compression and decompression
+  - Self-extracting capability for 7z format
+  - Strong AES-256 encryption in 7z and ZIP formats
+  - Integration with Windows Shell
+  - Powerful File Manager
+  - Powerful command line version
+  - Localizations for 90 languages
+
+
+7-Zip is free software distributed under the GNU LGPL (except for unRar code).
+Read License.txt for more information about license.
+
+
+  This distribution package contains the following files:
+
+  7zFM.exe      - 7-Zip File Manager
+  7-zip.dll     - Plugin for Windows Shell
+  7-zip32.dll   - Plugin for Windows Shell (32-bit plugin for 64-bit system)
+  7zg.exe       - GUI module
+  7z.exe        - Command line version
+  7z.dll        - 7-Zip engine module
+  7z.sfx        - SFX module (Windows version)
+  7zCon.sfx     - SFX module (Console version)
+
+  License.txt   - License information
+  readme.txt    - This file
+  History.txt   - History of 7-Zip
+  7-zip.chm     - User's Manual in HTML Help format
+  descript.ion  - Description for files
+
+  Lang\en.ttt   - English (base) localization file
+  Lang\*.txt    - Localization files
+
+
+---
+End of document

android-sdk/.knownPackages

@@ -0,0 +1 @@
+�/�[<�+ȝ�N�{~�

git/usr/share/perl5/core_perl/Term/Table.pm

@@ -0,0 +1,452 @@
+package Term::Table;
+use strict;
+use warnings;
+
+our $VERSION = '0.024';
+
+use Term::Table::Cell();
+
+use Term::Table::Util qw/term_size uni_length USE_GCS/;
+use Scalar::Util qw/blessed/;
+use List::Util qw/max sum/;
+use Carp qw/croak carp/;
+
+use Term::Table::HashBase qw/rows _columns collapse max_width mark_tail sanitize show_header auto_columns no_collapse header allow_overflow pad/;
+
+sub BORDER_SIZE()   { 4 }    # '| ' and ' |' borders
+sub DIV_SIZE()      { 3 }    # ' | ' column delimiter
+sub CELL_PAD_SIZE() { 2 }    # space on either side of the |
+
+sub init {
+    my $self = shift;
+
+    croak "You cannot have a table with no rows"
+        unless $self->{+ROWS} && @{$self->{+ROWS}};
+
+    $self->{+MAX_WIDTH}   ||= term_size();
+    $self->{+NO_COLLAPSE} ||= {};
+    if (ref($self->{+NO_COLLAPSE}) eq 'ARRAY') {
+        $self->{+NO_COLLAPSE} = {map { ($_ => 1) } @{$self->{+NO_COLLAPSE}}};
+    }
+
+    if ($self->{+NO_COLLAPSE} && $self->{+HEADER}) {
+        my $header = $self->{+HEADER};
+        for(my $idx = 0; $idx < @$header; $idx++) {
+            $self->{+NO_COLLAPSE}->{$idx} ||= $self->{+NO_COLLAPSE}->{$header->[$idx]};
+        }
+    }
+
+    $self->{+PAD} = 4 unless defined $self->{+PAD};
+
+    $self->{+COLLAPSE}  = 1 unless defined $self->{+COLLAPSE};
+    $self->{+SANITIZE}  = 1 unless defined $self->{+SANITIZE};
+    $self->{+MARK_TAIL} = 1 unless defined $self->{+MARK_TAIL};
+
+    if($self->{+HEADER}) {
+        $self->{+SHOW_HEADER}  = 1 unless defined $self->{+SHOW_HEADER};
+    }
+    else {
+        $self->{+HEADER}       = [];
+        $self->{+AUTO_COLUMNS} = 1;
+        $self->{+SHOW_HEADER}  = 0;
+    }
+}
+
+sub columns {
+    my $self = shift;
+
+    $self->regen_columns unless $self->{+_COLUMNS};
+
+    return $self->{+_COLUMNS};
+}
+
+sub regen_columns {
+    my $self = shift;
+
+    my $has_header = $self->{+SHOW_HEADER} && @{$self->{+HEADER}};
+    my %new_col = (width => 0, count => $has_header ? -1 : 0);
+
+    my $cols = [map { {%new_col} } @{$self->{+HEADER}}];
+    my @rows = @{$self->{+ROWS}};
+
+    for my $row ($has_header ? ($self->{+HEADER}, @rows) : (@rows)) {
+        for my $ci (0 .. max(@$cols - 1, @$row - 1)) {
+            $cols->[$ci] ||= {%new_col} if $self->{+AUTO_COLUMNS};
+            my $c = $cols->[$ci] or next;
+            $c->{idx}  ||= $ci;
+            $c->{rows} ||= [];
+
+            my $r = $row->[$ci];
+            $r = Term::Table::Cell->new(value => $r)
+                unless blessed($r)
+                && ($r->isa('Term::Table::Cell')
+                || $r->isa('Term::Table::CellStack')
+                || $r->isa('Term::Table::Spacer'));
+
+            $r->sanitize  if $self->{+SANITIZE};
+            $r->mark_tail if $self->{+MARK_TAIL};
+
+            my $rs = $r->width;
+            $c->{width} = $rs if $rs > $c->{width};
+            $c->{count}++ if $rs;
+
+            push @{$c->{rows}} => $r;
+        }
+    }
+
+    # Remove any empty columns we can
+    @$cols = grep {$_->{count} > 0 || $self->{+NO_COLLAPSE}->{$_->{idx}}} @$cols
+        if $self->{+COLLAPSE};
+
+    my $current = sum(map {$_->{width}} @$cols);
+    my $border = sum(BORDER_SIZE, $self->{+PAD}, DIV_SIZE * (@$cols - 1));
+    my $total = $current + $border;
+
+    if ($total > $self->{+MAX_WIDTH}) {
+        my $fair = ($self->{+MAX_WIDTH} - $border) / @$cols;
+        if ($fair < 1) {
+            return $self->{+_COLUMNS} = $cols if $self->{+ALLOW_OVERFLOW};
+            croak "Table is too large ($total including $self->{+PAD} padding) to fit into max-width ($self->{+MAX_WIDTH})";
+        }
+
+        my $under = 0;
+        my @fix;
+        for my $c (@$cols) {
+            if ($c->{width} > $fair) {
+                push @fix => $c;
+            }
+            else {
+                $under += $c->{width};
+            }
+        }
+
+        # Recalculate fairness
+        $fair = int(($self->{+MAX_WIDTH} - $border - $under) / @fix);
+        if ($fair < 1) {
+            return $self->{+_COLUMNS} = $cols if $self->{+ALLOW_OVERFLOW};
+            croak "Table is too large ($total including $self->{+PAD} padding) to fit into max-width ($self->{+MAX_WIDTH})";
+        }
+
+        # Adjust over-long columns
+        $_->{width} = $fair for @fix;
+    }
+
+    $self->{+_COLUMNS} = $cols;
+}
+
+sub render {
+    my $self = shift;
+
+    my $cols = $self->columns;
+    for my $col (@$cols) {
+        for my $cell (@{$col->{rows}}) {
+            $cell->reset;
+        }
+    }
+    my $width = sum(BORDER_SIZE, $self->{+PAD}, DIV_SIZE * @$cols, map { $_->{width} } @$cols);
+
+    #<<< NO-TIDY
+    my $border   = '+' . join('+', map { '-' x ($_->{width}  + CELL_PAD_SIZE) }      @$cols) . '+';
+    my $template = '|' . join('|', map { my $w = $_->{width} + CELL_PAD_SIZE; '%s' } @$cols) . '|';
+    my $spacer   = '|' . join('|', map { ' ' x ($_->{width}  + CELL_PAD_SIZE) }      @$cols) . '|';
+    #>>>
+
+    my @out = ($border);
+    my ($row, $split, $found) = (0, 0, 0);
+    while(1) {
+        my @row;
+
+        my $is_spacer = 0;
+
+        for my $col (@$cols) {
+            my $r = $col->{rows}->[$row];
+            unless($r) {
+                push @row => '';
+                next;
+            }
+
+            my ($v, $vw);
+
+            if ($r->isa('Term::Table::Cell')) {
+                my $lw = $r->border_left_width;
+                my $rw = $r->border_right_width;
+                $vw = $col->{width} - $lw - $rw;
+                $v = $r->break->next($vw);
+            }
+            elsif ($r->isa('Term::Table::CellStack')) {
+                ($v, $vw) = $r->break->next($col->{width});
+            }
+            elsif ($r->isa('Term::Table::Spacer')) {
+                $is_spacer = 1;
+            }
+
+            if ($is_spacer) {
+                last;
+            }
+            elsif (defined $v) {
+                $found++;
+                my $bcolor = $r->border_color || '';
+                my $vcolor = $r->value_color  || '';
+                my $reset  = $r->reset_color  || '';
+
+                if (my $need = $vw - uni_length($v)) {
+                    $v .= ' ' x $need;
+                }
+
+                my $rt = "${reset}${bcolor}\%s${reset} ${vcolor}\%s${reset} ${bcolor}\%s${reset}";
+                push @row => sprintf($rt, $r->border_left || '', $v, $r->border_right || '');
+            }
+            else {
+                push @row => ' ' x ($col->{width} + 2);
+            }
+        }
+
+        if (!grep {$_ && m/\S/} @row) {
+            last unless $found || $is_spacer;
+
+            push @out => $border if $row == 0 && $self->{+SHOW_HEADER} && @{$self->{+HEADER}};
+            push @out => $spacer if $split > 1 || $is_spacer;
+
+            $row++;
+            $split = 0;
+            $found = 0;
+
+            next;
+        }
+
+        if ($split == 1 && @out > 1 && $out[-2] ne $border && $out[-2] ne $spacer) {
+            my $last = pop @out;
+            push @out => ($spacer, $last);
+        }
+
+        push @out => sprintf($template, @row);
+        $split++;
+    }
+
+    pop @out while @out && $out[-1] eq $spacer;
+
+    unless (USE_GCS) {
+        for my $row (@out) {
+            next unless $row =~ m/[[:^ascii:]]/;
+            unshift @out => "Unicode::GCString is not installed, table may not display all unicode characters properly";
+            last;
+        }
+    }
+
+    return (@out, $border);
+}
+
+sub display {
+    my $self = shift;
+    my ($fh) = @_;
+
+    my @parts = map "$_\n", $self->render;
+
+    print $fh @parts if $fh;
+    print @parts;
+}
+
+1;
+
+__END__
+
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Term::Table - Format a header and rows into a table
+
+=head1 DESCRIPTION
+
+This is used by some failing tests to provide diagnostics about what has gone
+wrong. This module is able to format rows of data into tables.
+
+=head1 SYNOPSIS
+
+    use Term::Table;
+
+    my $table = Term::Table->new(
+        max_width      => 80,    # Defaults to terminal size
+        pad            => 4,     # Extra padding between table and max-width (defaults to 4)
+        allow_overflow => 0,     # Default is 0, when off an exception will be thrown if the table is too big
+        collapse       => 1,     # Do not show empty columns
+
+        header => ['name', 'age', 'hair color'],
+        rows   => [
+            ['Fred Flintstone',  2000000, 'black'],
+            ['Wilma Flintstone', 1999995, 'red'],
+            ...
+        ],
+    );
+
+    say $_ for $table->render;
+
+This prints a table like this:
+
+    +------------------+---------+------------+
+    | name             | age     | hair color |
+    +------------------+---------+------------+
+    | Fred Flintstone  | 2000000 | black      |
+    | Wilma Flintstone | 1999995 | red        |
+    | ...              | ...     | ...        |
+    +------------------+---------+------------+
+
+=head1 INTERFACE
+
+    use Term::Table;
+    my $table = Term::Table->new(...);
+
+=head2 OPTIONS
+
+=over 4
+
+=item header => [ ... ]
+
+If you want a header specify it here.
+This takes an arrayref with each columns heading.
+
+=item rows => [ [...], [...], ... ]
+
+This should be an arrayref containing an arrayref per row.
+
+=item collapse => $bool
+
+Use this if you want to hide empty columns, that is any column that has no data
+in any row. Having a header for the column will not effect collapse.
+
+=item max_width => $num
+
+Set the maximum width of the table, the table may not be this big, but it will
+be no bigger. If none is specified it will attempt to find the width of your
+terminal and use that, otherwise it falls back to the terminal width or C<80>.
+
+=item pad => $num
+
+Defaults to C<4>, extra padding for row width calculations.
+Default is for legacy support.
+Set this to C<0> to turn padding off.
+
+=item allow_overflow => $bool
+
+Defaults to C<0>. If this is off then an exception will be thrown if the table
+cannot be made to fit inside the max-width. If this is set to C<1> then the
+table will be rendered anyway, larger than max-width, if it is not possible
+to stay within the max-width. In other words this turns max-width from a
+hard-limit to a soft recommendation.
+
+=item sanitize => $bool
+
+This will sanitize all the data in the table such that newlines, control
+characters, and all whitespace except for ASCII 20 C<' '> are replaced with
+escape sequences. This prevents newlines, tabs, and similar whitespace from
+disrupting the table.
+
+B<Note:> newlines are marked as C<\n>, but a newline is also inserted into the
+data so that it typically displays in a way that is useful to humans.
+
+Example:
+
+    my $field = "foo\nbar\nbaz\n";
+
+    print join "\n" => table(
+        sanitize => 1,
+        rows => [
+            [$field,      'col2'     ],
+            ['row2 col1', 'row2 col2']
+        ]
+    );
+
+Prints:
+
+    +-----------------+-----------+
+    | foo\n           | col2      |
+    | bar\n           |           |
+    | baz\n           |           |
+    |                 |           |
+    | row2 col1       | row2 col2 |
+    +-----------------+-----------+
+
+So it marks the newlines by inserting the escape sequence, but it also shows
+the data across as many lines as it would normally display.
+
+=item mark_tail => $bool
+
+This will replace the last whitespace character of any trailing whitespace with
+its escape sequence. This makes it easier to notice trailing whitespace when
+comparing values.
+
+=item show_header => $bool
+
+Set this to false to hide the header. This defaults to true if the header is
+set, false if no header is provided.
+
+=item auto_columns => $bool
+
+Set this to true to automatically add columns that are not named in the header.
+This defaults to false if a header is provided, and defaults to true when there
+is no header.
+
+=item no_collapse => [ $col_num_a, $col_num_b, ... ]
+
+=item no_collapse => [ $col_name_a, $col_name_b, ... ]
+
+=item no_collapse => { $col_num_a => 1, $col_num_b => 1, ... }
+
+=item no_collapse => { $col_name_a => 1, $col_name_b => 1, ... }
+
+Specify (by number and/or name) columns that should not be removed when empty.
+The 'name' form only works when a header is specified. There is currently no
+protection to insure that names you specify are actually in the header, invalid
+names are ignored, patches to fix this will be happily accepted.
+
+=back
+
+=head1 NOTE ON UNICODE/WIDE CHARACTERS
+
+Some unicode characters, such as C<婧> (C<U+5A67>) are wider than others. These
+will render just fine if you C<use utf8;> as necessary, and
+L<Unicode::GCString> is installed, however if the module is not installed there
+will be anomalies in the table:
+
+    +-----+-----+---+
+    | a   | b   | c |
+    +-----+-----+---+
+    | 婧 | x   | y |
+    | x   | y   | z |
+    | x   | 婧 | z |
+    +-----+-----+---+
+
+=head1 SOURCE
+
+The source code repository for C<Term-Table> can be found at
+L<https://github.com/exodist/Term-Table/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2016 Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test/Builder.pm

@@ -0,0 +1,2646 @@
+package Test::Builder;
+
+use 5.006;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+use Scalar::Util qw/blessed reftype weaken/;
+
+use Test2::Util qw/USE_THREADS try get_tid/;
+use Test2::API qw/context release/;
+# Make Test::Builder thread-safe for ithreads.
+BEGIN {
+    warn "Test::Builder was loaded after Test2 initialization, this is not recommended."
+        if Test2::API::test2_init_done() || Test2::API::test2_load_done();
+
+    if (USE_THREADS && ! Test2::API::test2_ipc_disabled()) {
+        require Test2::IPC;
+        require Test2::IPC::Driver::Files;
+        Test2::IPC::Driver::Files->import;
+        Test2::API::test2_ipc_enable_polling();
+        Test2::API::test2_no_wait(1);
+    }
+}
+
+use Test2::Event::Subtest;
+use Test2::Hub::Subtest;
+
+use Test::Builder::Formatter;
+use Test::Builder::TodoDiag;
+
+our $Level = 1;
+our $Test = $ENV{TB_NO_EARLY_INIT} ? undef : Test::Builder->new;
+
+sub _add_ts_hooks {
+    my $self = shift;
+
+    my $hub = $self->{Stack}->top;
+
+    # Take a reference to the hash key, we do this to avoid closing over $self
+    # which is the singleton. We use a reference because the value could change
+    # in rare cases.
+    my $epkgr = \$self->{Exported_To};
+
+    #$hub->add_context_aquire(sub {$_[0]->{level} += $Level - 1});
+
+    $hub->pre_filter(
+        sub {
+            my ($active_hub, $e) = @_;
+
+            my $epkg = $$epkgr;
+            my $cpkg = $e->{trace} ? $e->{trace}->{frame}->[0] : undef;
+
+            no strict 'refs';
+            no warnings 'once';
+            my $todo;
+            $todo = ${"$cpkg\::TODO"} if $cpkg;
+            $todo = ${"$epkg\::TODO"} if $epkg && !$todo;
+
+            return $e unless defined($todo);
+            return $e unless length($todo);
+
+            # Turn a diag into a todo diag
+            return Test::Builder::TodoDiag->new(%$e) if ref($e) eq 'Test2::Event::Diag';
+
+            $e->set_todo($todo) if $e->can('set_todo');
+            $e->add_amnesty({tag => 'TODO', details => $todo});
+
+            # Set todo on ok's
+            if ($e->isa('Test2::Event::Ok')) {
+                $e->set_effective_pass(1);
+
+                if (my $result = $e->get_meta(__PACKAGE__)) {
+                    $result->{reason} ||= $todo;
+                    $result->{type}   ||= 'todo';
+                    $result->{ok} = 1;
+                }
+            }
+
+            return $e;
+        },
+
+        inherit => 1,
+
+        intercept_inherit => {
+            clean => sub {
+                my %params = @_;
+
+                my $state = $params{state};
+                my $trace = $params{trace};
+
+                my $epkg = $$epkgr;
+                my $cpkg = $trace->{frame}->[0];
+
+                no strict 'refs';
+                no warnings 'once';
+
+                $state->{+__PACKAGE__} = {};
+                $state->{+__PACKAGE__}->{"$cpkg\::TODO"} = ${"$cpkg\::TODO"} if $cpkg;
+                $state->{+__PACKAGE__}->{"$epkg\::TODO"} = ${"$epkg\::TODO"} if $epkg;
+
+                ${"$cpkg\::TODO"} = undef if $cpkg;
+                ${"$epkg\::TODO"} = undef if $epkg;
+            },
+            restore => sub {
+                my %params = @_;
+                my $state = $params{state};
+
+                no strict 'refs';
+                no warnings 'once';
+
+                for my $item (keys %{$state->{+__PACKAGE__}}) {
+                    no strict 'refs';
+                    no warnings 'once';
+
+                    ${"$item"} = $state->{+__PACKAGE__}->{$item};
+                }
+            },
+        },
+    );
+}
+
+{
+    no warnings;
+    INIT {
+        use warnings;
+        Test2::API::test2_load() unless Test2::API::test2_in_preload();
+    }
+}
+
+sub new {
+    my($class) = shift;
+    unless($Test) {
+        $Test = $class->create(singleton => 1);
+
+        Test2::API::test2_add_callback_post_load(
+            sub {
+                $Test->{Original_Pid} = $$ if !$Test->{Original_Pid} || $Test->{Original_Pid} == 0;
+                $Test->reset(singleton => 1);
+                $Test->_add_ts_hooks;
+            }
+        );
+
+        # Non-TB tools normally expect 0 added to the level. $Level is normally 1. So
+        # we only want the level to change if $Level != 1.
+        # TB->ctx compensates for this later.
+        Test2::API::test2_add_callback_context_aquire(sub { $_[0]->{level} += $Level - 1 });
+
+        Test2::API::test2_add_callback_exit(sub { $Test->_ending(@_) });
+
+        Test2::API::test2_ipc()->set_no_fatal(1) if Test2::API::test2_has_ipc();
+    }
+    return $Test;
+}
+
+sub create {
+    my $class = shift;
+    my %params = @_;
+
+    my $self = bless {}, $class;
+    if ($params{singleton}) {
+        $self->{Stack} = Test2::API::test2_stack();
+    }
+    else {
+        $self->{Stack} = Test2::API::Stack->new;
+        $self->{Stack}->new_hub(
+            formatter => Test::Builder::Formatter->new,
+            ipc       => Test2::API::test2_ipc(),
+        );
+
+        $self->reset(%params);
+        $self->_add_ts_hooks;
+    }
+
+    return $self;
+}
+
+sub ctx {
+    my $self = shift;
+    context(
+        # 1 for our frame, another for the -1 off of $Level in our hook at the top.
+        level   => 2,
+        fudge   => 1,
+        stack   => $self->{Stack},
+        hub     => $self->{Hub},
+        wrapped => 1,
+        @_
+    );
+}
+
+sub parent {
+    my $self = shift;
+    my $ctx = $self->ctx;
+    my $chub = $self->{Hub} || $ctx->hub;
+    $ctx->release;
+
+    my $meta = $chub->meta(__PACKAGE__, {});
+    my $parent = $meta->{parent};
+
+    return undef unless $parent;
+
+    return bless {
+        Original_Pid => $$,
+        Stack => $self->{Stack},
+        Hub => $parent,
+    }, blessed($self);
+}
+
+sub child {
+    my( $self, $name ) = @_;
+
+    $name ||= "Child of " . $self->name;
+    my $ctx = $self->ctx;
+
+    my $parent = $ctx->hub;
+    my $pmeta = $parent->meta(__PACKAGE__, {});
+    $self->croak("You already have a child named ($pmeta->{child}) running")
+        if $pmeta->{child};
+
+    $pmeta->{child} = $name;
+
+    # Clear $TODO for the child.
+    my $orig_TODO = $self->find_TODO(undef, 1, undef);
+
+    my $subevents = [];
+
+    my $hub = $ctx->stack->new_hub(
+        class => 'Test2::Hub::Subtest',
+    );
+
+    $hub->pre_filter(sub {
+        my ($active_hub, $e) = @_;
+
+        # Turn a diag into a todo diag
+        return Test::Builder::TodoDiag->new(%$e) if ref($e) eq 'Test2::Event::Diag';
+
+        return $e;
+    }, inherit => 1) if $orig_TODO;
+
+    $hub->listen(sub { push @$subevents => $_[1] });
+
+    $hub->set_nested( $parent->nested + 1 );
+
+    my $meta = $hub->meta(__PACKAGE__, {});
+    $meta->{Name} = $name;
+    $meta->{TODO} = $orig_TODO;
+    $meta->{TODO_PKG} = $ctx->trace->package;
+    $meta->{parent} = $parent;
+    $meta->{Test_Results} = [];
+    $meta->{subevents} = $subevents;
+    $meta->{subtest_id} = $hub->id;
+    $meta->{subtest_uuid} = $hub->uuid;
+    $meta->{subtest_buffered} = $parent->format ? 0 : 1;
+
+    $self->_add_ts_hooks;
+
+    $ctx->release;
+    return bless { Original_Pid => $$, Stack => $self->{Stack}, Hub => $hub, no_log_results => $self->{no_log_results} }, blessed($self);
+}
+
+sub finalize {
+    my $self = shift;
+    my $ok = 1;
+    ($ok) = @_ if @_;
+
+    my $st_ctx = $self->ctx;
+    my $chub = $self->{Hub} || return $st_ctx->release;
+
+    my $meta = $chub->meta(__PACKAGE__, {});
+    if ($meta->{child}) {
+        $self->croak("Can't call finalize() with child ($meta->{child}) active");
+    }
+
+    local $? = 0;     # don't fail if $subtests happened to set $? nonzero
+
+    $self->{Stack}->pop($chub);
+
+    $self->find_TODO($meta->{TODO_PKG}, 1, $meta->{TODO});
+
+    my $parent = $self->parent;
+    my $ctx = $parent->ctx;
+    my $trace = $ctx->trace;
+    delete $ctx->hub->meta(__PACKAGE__, {})->{child};
+
+    $chub->finalize($trace->snapshot(hid => $chub->hid, nested => $chub->nested), 1)
+        if $ok
+        && $chub->count
+        && !$chub->no_ending
+        && !$chub->ended;
+
+    my $plan   = $chub->plan || 0;
+    my $count  = $chub->count;
+    my $failed = $chub->failed;
+    my $passed = $chub->is_passing;
+
+    my $num_extra = $plan =~ m/\D/ ? 0 : $count - $plan;
+    if ($count && $num_extra != 0) {
+        my $s = $plan == 1 ? '' : 's';
+        $st_ctx->diag(<<"FAIL");
+Looks like you planned $plan test$s but ran $count.
+FAIL
+    }
+
+    if ($failed) {
+        my $s = $failed == 1 ? '' : 's';
+
+        my $qualifier = $num_extra == 0 ? '' : ' run';
+
+        $st_ctx->diag(<<"FAIL");
+Looks like you failed $failed test$s of $count$qualifier.
+FAIL
+    }
+
+    if (!$passed && !$failed && $count && !$num_extra) {
+        $st_ctx->diag(<<"FAIL");
+All assertions inside the subtest passed, but errors were encountered.
+FAIL
+    }
+
+    $st_ctx->release;
+
+    unless ($chub->bailed_out) {
+        my $plan = $chub->plan;
+        if ( $plan && $plan eq 'SKIP' ) {
+            $parent->skip($chub->skip_reason, $meta->{Name});
+        }
+        elsif ( !$chub->count ) {
+            $parent->ok( 0, sprintf q[No tests run for subtest "%s"], $meta->{Name} );
+        }
+        else {
+            $parent->{subevents}  = $meta->{subevents};
+            $parent->{subtest_id} = $meta->{subtest_id};
+            $parent->{subtest_uuid} = $meta->{subtest_uuid};
+            $parent->{subtest_buffered} = $meta->{subtest_buffered};
+            $parent->ok( $chub->is_passing, $meta->{Name} );
+        }
+    }
+
+    $ctx->release;
+    return $chub->is_passing;
+}
+
+sub subtest {
+    my $self = shift;
+    my ($name, $code, @args) = @_;
+    my $ctx = $self->ctx;
+    $ctx->throw("subtest()'s second argument must be a code ref")
+        unless $code && reftype($code) eq 'CODE';
+
+    $name ||= "Child of " . $self->name;
+
+
+    $_->($name,$code,@args)
+        for Test2::API::test2_list_pre_subtest_callbacks();
+
+    $ctx->note("Subtest: $name");
+
+    my $child = $self->child($name);
+
+    my $start_pid = $$;
+    my $st_ctx;
+    my ($ok, $err, $finished, $child_error);
+    T2_SUBTEST_WRAPPER: {
+        my $ctx = $self->ctx;
+        $st_ctx = $ctx->snapshot;
+        $ctx->release;
+        $ok = eval { local $Level = 1; $code->(@args); 1 };
+        ($err, $child_error) = ($@, $?);
+
+        # They might have done 'BEGIN { skip_all => "whatever" }'
+        if (!$ok && $err =~ m/Label not found for "last T2_SUBTEST_WRAPPER"/ || (blessed($err) && blessed($err) eq 'Test::Builder::Exception')) {
+            $ok  = undef;
+            $err = undef;
+        }
+        else {
+            $finished = 1;
+        }
+    }
+
+    if ($start_pid != $$ && !$INC{'Test2/IPC.pm'}) {
+        warn $ok ? "Forked inside subtest, but subtest never finished!\n" : $err;
+        exit 255;
+    }
+
+    my $trace = $ctx->trace;
+
+    if (!$finished) {
+        if(my $bailed = $st_ctx->hub->bailed_out) {
+            my $chub = $child->{Hub};
+            $self->{Stack}->pop($chub);
+            $ctx->bail($bailed->reason);
+        }
+        my $code = $st_ctx->hub->exit_code;
+        $ok = !$code;
+        $err = "Subtest ended with exit code $code" if $code;
+    }
+
+    my $st_hub  = $st_ctx->hub;
+    my $plan  = $st_hub->plan;
+    my $count = $st_hub->count;
+
+    if (!$count && (!defined($plan) || "$plan" ne 'SKIP')) {
+        $st_ctx->plan(0) unless defined $plan;
+        $st_ctx->diag('No tests run!');
+    }
+
+    $child->finalize($st_ctx->trace);
+
+    $ctx->release;
+
+    die $err unless $ok;
+
+    $? = $child_error if defined $child_error;
+
+    return $st_hub->is_passing;
+}
+
+sub name {
+    my $self = shift;
+    my $ctx = $self->ctx;
+    release $ctx, $ctx->hub->meta(__PACKAGE__, {})->{Name};
+}
+
+sub reset {    ## no critic (Subroutines::ProhibitBuiltinHomonyms)
+    my ($self, %params) = @_;
+
+    Test2::API::test2_unset_is_end();
+
+    # We leave this a global because it has to be localized and localizing
+    # hash keys is just asking for pain.  Also, it was documented.
+    $Level = 1;
+
+    $self->{no_log_results} = $ENV{TEST_NO_LOG_RESULTS} ? 1 : 0
+        unless $params{singleton};
+
+    $self->{Original_Pid} = Test2::API::test2_in_preload() ? -1 : $$;
+
+    my $ctx = $self->ctx;
+    my $hub = $ctx->hub;
+    $ctx->release;
+    unless ($params{singleton}) {
+        $hub->reset_state();
+        $hub->_tb_reset();
+    }
+
+    $ctx = $self->ctx;
+
+    my $meta = $ctx->hub->meta(__PACKAGE__, {});
+    %$meta = (
+        Name         => $0,
+        Ending       => 0,
+        Done_Testing => undef,
+        Skip_All     => 0,
+        Test_Results => [],
+        parent       => $meta->{parent},
+    );
+
+    $self->{Exported_To} = undef unless $params{singleton};
+
+    $self->{Orig_Handles} ||= do {
+        my $format = $ctx->hub->format;
+        my $out;
+        if ($format && $format->isa('Test2::Formatter::TAP')) {
+            $out = $format->handles;
+        }
+        $out ? [@$out] : [];
+    };
+
+    $self->use_numbers(1);
+    $self->no_header(0) unless $params{singleton};
+    $self->no_ending(0) unless $params{singleton};
+    $self->reset_outputs;
+
+    $ctx->release;
+
+    return;
+}
+
+
+my %plan_cmds = (
+    no_plan  => \&no_plan,
+    skip_all => \&skip_all,
+    tests    => \&_plan_tests,
+);
+
+sub plan {
+    my( $self, $cmd, $arg ) = @_;
+
+    return unless $cmd;
+
+    my $ctx = $self->ctx;
+    my $hub = $ctx->hub;
+
+    $ctx->throw("You tried to plan twice") if $hub->plan;
+
+    local $Level = $Level + 1;
+
+    if( my $method = $plan_cmds{$cmd} ) {
+        local $Level = $Level + 1;
+        $self->$method($arg);
+    }
+    else {
+        my @args = grep { defined } ( $cmd, $arg );
+        $ctx->throw("plan() doesn't understand @args");
+    }
+
+    release $ctx, 1;
+}
+
+
+sub _plan_tests {
+    my($self, $arg) = @_;
+
+    my $ctx = $self->ctx;
+
+    if($arg) {
+        local $Level = $Level + 1;
+        $self->expected_tests($arg);
+    }
+    elsif( !defined $arg ) {
+        $ctx->throw("Got an undefined number of tests");
+    }
+    else {
+        $ctx->throw("You said to run 0 tests");
+    }
+
+    $ctx->release;
+}
+
+
+sub expected_tests {
+    my $self = shift;
+    my($max) = @_;
+
+    my $ctx = $self->ctx;
+
+    if(@_) {
+        $self->croak("Number of tests must be a positive integer.  You gave it '$max'")
+          unless $max =~ /^\+?\d+$/;
+
+        $ctx->plan($max);
+    }
+
+    my $hub = $ctx->hub;
+
+    $ctx->release;
+
+    my $plan = $hub->plan;
+    return 0 unless $plan;
+    return 0 if $plan =~ m/\D/;
+    return $plan;
+}
+
+
+sub no_plan {
+    my($self, $arg) = @_;
+
+    my $ctx = $self->ctx;
+
+    if (defined $ctx->hub->plan) {
+        warn "Plan already set, no_plan() is a no-op, this will change to a hard failure in the future.";
+        $ctx->release;
+        return;
+    }
+
+    $ctx->alert("no_plan takes no arguments") if $arg;
+
+    $ctx->hub->plan('NO PLAN');
+
+    release $ctx, 1;
+}
+
+
+sub done_testing {
+    my($self, $num_tests) = @_;
+
+    my $ctx = $self->ctx;
+
+    my $meta = $ctx->hub->meta(__PACKAGE__, {});
+
+    if ($meta->{Done_Testing}) {
+        my ($file, $line) = @{$meta->{Done_Testing}}[1,2];
+        local $ctx->hub->{ended}; # OMG This is awful.
+        $self->ok(0, "done_testing() was already called at $file line $line");
+        $ctx->release;
+        return;
+    }
+    $meta->{Done_Testing} = [$ctx->trace->call];
+
+    my $plan = $ctx->hub->plan;
+    my $count = $ctx->hub->count;
+
+    # If done_testing() specified the number of tests, shut off no_plan
+    if( defined $num_tests ) {
+        $ctx->plan($num_tests) if !$plan || $plan eq 'NO PLAN';
+    }
+    elsif ($count && defined $num_tests && $count != $num_tests) {
+        $self->ok(0, "planned to run @{[ $self->expected_tests ]} but done_testing() expects $num_tests");
+    }
+    else {
+        $num_tests = $self->current_test;
+    }
+
+    if( $self->expected_tests && $num_tests != $self->expected_tests ) {
+        $self->ok(0, "planned to run @{[ $self->expected_tests ]} ".
+                     "but done_testing() expects $num_tests");
+    }
+
+    $ctx->plan($num_tests) if $ctx->hub->plan && $ctx->hub->plan eq 'NO PLAN';
+
+    $ctx->hub->finalize($ctx->trace, 1);
+
+    release $ctx, 1;
+}
+
+
+sub has_plan {
+    my $self = shift;
+
+    my $ctx = $self->ctx;
+    my $plan = $ctx->hub->plan;
+    $ctx->release;
+
+    return( $plan ) if $plan && $plan !~ m/\D/;
+    return('no_plan') if $plan && $plan eq 'NO PLAN';
+    return(undef);
+}
+
+
+sub skip_all {
+    my( $self, $reason ) = @_;
+
+    my $ctx = $self->ctx;
+
+    $ctx->hub->meta(__PACKAGE__, {})->{Skip_All} = $reason || 1;
+
+    # Work around old perl bug
+    if ($] < 5.020000) {
+        my $begin = 0;
+        my $level = 0;
+        while (my @call = caller($level++)) {
+            last unless @call && $call[0];
+            next unless $call[3] =~ m/::BEGIN$/;
+            $begin++;
+            last;
+        }
+        # HACK!
+        die 'Label not found for "last T2_SUBTEST_WRAPPER"' if $begin && $ctx->hub->meta(__PACKAGE__, {})->{parent};
+    }
+
+    $reason = "$reason" if defined $reason;
+
+    $ctx->plan(0, SKIP => $reason);
+}
+
+
+sub exported_to {
+    my( $self, $pack ) = @_;
+
+    if( defined $pack ) {
+        $self->{Exported_To} = $pack;
+    }
+    return $self->{Exported_To};
+}
+
+
+sub ok {
+    my( $self, $test, $name ) = @_;
+
+    my $ctx = $self->ctx;
+
+    # $test might contain an object which we don't want to accidentally
+    # store, so we turn it into a boolean.
+    $test = $test ? 1 : 0;
+
+    # In case $name is a string overloaded object, force it to stringify.
+    no  warnings qw/uninitialized numeric/;
+    $name = "$name" if defined $name;
+
+    # Profiling showed that the regex here was a huge time waster, doing the
+    # numeric addition first cuts our profile time from ~300ms to ~50ms
+    $self->diag(<<"    ERR") if 0 + $name && $name =~ /^[\d\s]+$/;
+    You named your test '$name'.  You shouldn't use numbers for your test names.
+    Very confusing.
+    ERR
+    use warnings qw/uninitialized numeric/;
+
+    my $trace = $ctx->{trace};
+    my $hub   = $ctx->{hub};
+
+    my $result = {
+        ok => $test,
+        actual_ok => $test,
+        reason => '',
+        type => '',
+        (name => defined($name) ? $name : ''),
+    };
+
+    $hub->{_meta}->{+__PACKAGE__}->{Test_Results}[ $hub->{count} ] = $result unless $self->{no_log_results};
+
+    my $orig_name = $name;
+
+    my @attrs;
+    my $subevents  = delete $self->{subevents};
+    my $subtest_id = delete $self->{subtest_id};
+    my $subtest_uuid = delete $self->{subtest_uuid};
+    my $subtest_buffered = delete $self->{subtest_buffered};
+    my $epkg = 'Test2::Event::Ok';
+    if ($subevents) {
+        $epkg = 'Test2::Event::Subtest';
+        push @attrs => (subevents => $subevents, subtest_id => $subtest_id, subtest_uuid => $subtest_uuid, buffered => $subtest_buffered);
+    }
+
+    my $e = bless {
+        trace => bless( {%$trace}, 'Test2::EventFacet::Trace'),
+        pass  => $test,
+        name  => $name,
+        _meta => {'Test::Builder' => $result},
+        effective_pass => $test,
+        @attrs,
+    }, $epkg;
+    $hub->send($e);
+
+    $self->_ok_debug($trace, $orig_name) unless($test);
+
+    $ctx->release;
+    return $test;
+}
+
+sub _ok_debug {
+    my $self = shift;
+    my ($trace, $orig_name) = @_;
+
+    my $is_todo = $self->in_todo;
+
+    my $msg = $is_todo ? "Failed (TODO)" : "Failed";
+
+    my (undef, $file, $line) = $trace->call;
+    if (defined $orig_name) {
+        $self->diag(qq[  $msg test '$orig_name'\n  at $file line $line.\n]);
+    }
+    else {
+        $self->diag(qq[  $msg test at $file line $line.\n]);
+    }
+}
+
+sub _diag_fh {
+    my $self = shift;
+    local $Level = $Level + 1;
+    return $self->in_todo ? $self->todo_output : $self->failure_output;
+}
+
+sub _unoverload {
+    my ($self, $type, $thing) = @_;
+
+    return unless ref $$thing;
+    return unless blessed($$thing) || scalar $self->_try(sub{ $$thing->isa('UNIVERSAL') });
+    {
+        local ($!, $@);
+        require overload;
+    }
+    my $string_meth = overload::Method( $$thing, $type ) || return;
+    $$thing = $$thing->$string_meth(undef, 0);
+}
+
+sub _unoverload_str {
+    my $self = shift;
+
+    $self->_unoverload( q[""], $_ ) for @_;
+}
+
+sub _unoverload_num {
+    my $self = shift;
+
+    $self->_unoverload( '0+', $_ ) for @_;
+
+    for my $val (@_) {
+        next unless $self->_is_dualvar($$val);
+        $$val = $$val + 0;
+    }
+}
+
+# This is a hack to detect a dualvar such as $!
+sub _is_dualvar {
+    my( $self, $val ) = @_;
+
+    # Objects are not dualvars.
+    return 0 if ref $val;
+
+    no warnings 'numeric';
+    my $numval = $val + 0;
+    return ($numval != 0 and $numval ne $val ? 1 : 0);
+}
+
+
+sub is_eq {
+    my( $self, $got, $expect, $name ) = @_;
+
+    my $ctx = $self->ctx;
+
+    local $Level = $Level + 1;
+
+    if( !defined $got || !defined $expect ) {
+        # undef only matches undef and nothing else
+        my $test = !defined $got && !defined $expect;
+
+        $self->ok( $test, $name );
+        $self->_is_diag( $got, 'eq', $expect ) unless $test;
+        $ctx->release;
+        return $test;
+    }
+
+    release $ctx, $self->cmp_ok( $got, 'eq', $expect, $name );
+}
+
+
+sub is_num {
+    my( $self, $got, $expect, $name ) = @_;
+    my $ctx = $self->ctx;
+    local $Level = $Level + 1;
+
+    if( !defined $got || !defined $expect ) {
+        # undef only matches undef and nothing else
+        my $test = !defined $got && !defined $expect;
+
+        $self->ok( $test, $name );
+        $self->_is_diag( $got, '==', $expect ) unless $test;
+        $ctx->release;
+        return $test;
+    }
+
+    release $ctx, $self->cmp_ok( $got, '==', $expect, $name );
+}
+
+
+sub _diag_fmt {
+    my( $self, $type, $val ) = @_;
+
+    if( defined $$val ) {
+        if( $type eq 'eq' or $type eq 'ne' ) {
+            # quote and force string context
+            $$val = "'$$val'";
+        }
+        else {
+            # force numeric context
+            $self->_unoverload_num($val);
+        }
+    }
+    else {
+        $$val = 'undef';
+    }
+
+    return;
+}
+
+
+sub _is_diag {
+    my( $self, $got, $type, $expect ) = @_;
+
+    $self->_diag_fmt( $type, $_ ) for \$got, \$expect;
+
+    local $Level = $Level + 1;
+    return $self->diag(<<"DIAGNOSTIC");
+         got: $got
+    expected: $expect
+DIAGNOSTIC
+
+}
+
+sub _isnt_diag {
+    my( $self, $got, $type ) = @_;
+
+    $self->_diag_fmt( $type, \$got );
+
+    local $Level = $Level + 1;
+    return $self->diag(<<"DIAGNOSTIC");
+         got: $got
+    expected: anything else
+DIAGNOSTIC
+}
+
+
+sub isnt_eq {
+    my( $self, $got, $dont_expect, $name ) = @_;
+    my $ctx = $self->ctx;
+    local $Level = $Level + 1;
+
+    if( !defined $got || !defined $dont_expect ) {
+        # undef only matches undef and nothing else
+        my $test = defined $got || defined $dont_expect;
+
+        $self->ok( $test, $name );
+        $self->_isnt_diag( $got, 'ne' ) unless $test;
+        $ctx->release;
+        return $test;
+    }
+
+    release $ctx, $self->cmp_ok( $got, 'ne', $dont_expect, $name );
+}
+
+sub isnt_num {
+    my( $self, $got, $dont_expect, $name ) = @_;
+    my $ctx = $self->ctx;
+    local $Level = $Level + 1;
+
+    if( !defined $got || !defined $dont_expect ) {
+        # undef only matches undef and nothing else
+        my $test = defined $got || defined $dont_expect;
+
+        $self->ok( $test, $name );
+        $self->_isnt_diag( $got, '!=' ) unless $test;
+        $ctx->release;
+        return $test;
+    }
+
+    release $ctx, $self->cmp_ok( $got, '!=', $dont_expect, $name );
+}
+
+
+sub like {
+    my( $self, $thing, $regex, $name ) = @_;
+    my $ctx = $self->ctx;
+
+    local $Level = $Level + 1;
+
+    release $ctx, $self->_regex_ok( $thing, $regex, '=~', $name );
+}
+
+sub unlike {
+    my( $self, $thing, $regex, $name ) = @_;
+    my $ctx = $self->ctx;
+
+    local $Level = $Level + 1;
+
+    release $ctx, $self->_regex_ok( $thing, $regex, '!~', $name );
+}
+
+
+my %numeric_cmps = map { ( $_, 1 ) } ( "<", "<=", ">", ">=", "==", "!=", "<=>" );
+
+# Bad, these are not comparison operators. Should we include more?
+my %cmp_ok_bl = map { ( $_, 1 ) } ( "=", "+=", ".=", "x=", "^=", "|=", "||=", "&&=", "...");
+
+sub cmp_ok {
+    my( $self, $got, $type, $expect, $name ) = @_;
+    my $ctx = $self->ctx;
+
+    if ($cmp_ok_bl{$type}) {
+        $ctx->throw("$type is not a valid comparison operator in cmp_ok()");
+    }
+
+    my ($test, $succ);
+    my $error;
+    {
+        ## no critic (BuiltinFunctions::ProhibitStringyEval)
+
+        local( $@, $!, $SIG{__DIE__} );    # isolate eval
+
+        my($pack, $file, $line) = $ctx->trace->call();
+        my $warning_bits = $ctx->trace->warning_bits;
+        # convert this to a code string so the BEGIN doesn't have to close
+        # over it, which can lead to issues with Devel::Cover
+        my $bits_code = defined $warning_bits ? qq["\Q$warning_bits\E"] : 'undef';
+
+        # Make sure warnings and location matches the caller. Can't do the
+        # comparison directly in the eval, as closing over variables can
+        # capture them forever when running with Devel::Cover.
+        my $check;
+        $succ = eval qq[
+BEGIN {\${^WARNING_BITS} = $bits_code};
+#line $line "(eval in cmp_ok) $file"
+\$check = sub { \$_[0] $type \$_[1] };
+1;
+];
+
+        if ($succ) {
+            $succ = eval {
+                $test = $check->($got, $expect);
+                1;
+            };
+        }
+        $error = $@;
+    }
+    local $Level = $Level + 1;
+    my $ok = $self->ok( $test, $name );
+
+    # Treat overloaded objects as numbers if we're asked to do a
+    # numeric comparison.
+    my $unoverload
+      = $numeric_cmps{$type}
+      ? '_unoverload_num'
+      : '_unoverload_str';
+
+    $self->diag(<<"END") unless $succ;
+An error occurred while using $type:
+------------------------------------
+$error
+------------------------------------
+END
+
+    unless($ok) {
+        $self->$unoverload( \$got, \$expect );
+
+        if( $type =~ /^(eq|==)$/ ) {
+            $self->_is_diag( $got, $type, $expect );
+        }
+        elsif( $type =~ /^(ne|!=)$/ ) {
+            if (defined($got) xor defined($expect)) {
+                $self->_cmp_diag( $got, $type, $expect );
+            }
+            else {
+                $self->_isnt_diag( $got, $type );
+            }
+        }
+        else {
+            $self->_cmp_diag( $got, $type, $expect );
+        }
+    }
+    return release $ctx, $ok;
+}
+
+sub _cmp_diag {
+    my( $self, $got, $type, $expect ) = @_;
+
+    $got    = defined $got    ? "'$got'"    : 'undef';
+    $expect = defined $expect ? "'$expect'" : 'undef';
+
+    local $Level = $Level + 1;
+    return $self->diag(<<"DIAGNOSTIC");
+    $got
+        $type
+    $expect
+DIAGNOSTIC
+}
+
+sub _caller_context {
+    my $self = shift;
+
+    my( $pack, $file, $line ) = $self->caller(1);
+
+    my $code = '';
+    $code .= "#line $line $file\n" if defined $file and defined $line;
+
+    return $code;
+}
+
+
+sub BAIL_OUT {
+    my( $self, $reason ) = @_;
+
+    my $ctx = $self->ctx;
+
+    $self->{Bailed_Out} = 1;
+
+    $ctx->bail($reason);
+}
+
+
+{
+    no warnings 'once';
+    *BAILOUT = \&BAIL_OUT;
+}
+
+sub skip {
+    my( $self, $why, $name ) = @_;
+    $why ||= '';
+    $name = '' unless defined $name;
+    $self->_unoverload_str( \$why );
+
+    my $ctx = $self->ctx;
+
+    $name = "$name";
+    $why  = "$why";
+
+    $name =~ s|#|\\#|g;    # # in a name can confuse Test::Harness.
+    $name =~ s{\n}{\n# }sg;
+    $why =~ s{\n}{\n# }sg;
+
+    $ctx->hub->meta(__PACKAGE__, {})->{Test_Results}[ $ctx->hub->count ] = {
+        'ok'      => 1,
+        actual_ok => 1,
+        name      => $name,
+        type      => 'skip',
+        reason    => $why,
+    } unless $self->{no_log_results};
+
+    my $tctx = $ctx->snapshot;
+    $tctx->skip('', $why);
+
+    return release $ctx, 1;
+}
+
+
+sub todo_skip {
+    my( $self, $why ) = @_;
+    $why ||= '';
+
+    my $ctx = $self->ctx;
+
+    $ctx->hub->meta(__PACKAGE__, {})->{Test_Results}[ $ctx->hub->count ] = {
+        'ok'      => 1,
+        actual_ok => 0,
+        name      => '',
+        type      => 'todo_skip',
+        reason    => $why,
+    } unless $self->{no_log_results};
+
+    $why =~ s{\n}{\n# }sg;
+    my $tctx = $ctx->snapshot;
+    $tctx->send_event( 'Skip', todo => $why, todo_diag => 1, reason => $why, pass => 0);
+
+    return release $ctx, 1;
+}
+
+
+sub maybe_regex {
+    my( $self, $regex ) = @_;
+    my $usable_regex = undef;
+
+    return $usable_regex unless defined $regex;
+
+    my( $re, $opts );
+
+    # Check for qr/foo/
+    if( _is_qr($regex) ) {
+        $usable_regex = $regex;
+    }
+    # Check for '/foo/' or 'm,foo,'
+    elsif(( $re, $opts )        = $regex =~ m{^ /(.*)/ (\w*) $ }sx              or
+          ( undef, $re, $opts ) = $regex =~ m,^ m([^\w\s]) (.+) \1 (\w*) $,sx
+    )
+    {
+        $usable_regex = length $opts ? "(?$opts)$re" : $re;
+    }
+
+    return $usable_regex;
+}
+
+sub _is_qr {
+    my $regex = shift;
+
+    # is_regexp() checks for regexes in a robust manner, say if they're
+    # blessed.
+    return re::is_regexp($regex) if defined &re::is_regexp;
+    return ref $regex eq 'Regexp';
+}
+
+sub _regex_ok {
+    my( $self, $thing, $regex, $cmp, $name ) = @_;
+
+    my $ok           = 0;
+    my $usable_regex = $self->maybe_regex($regex);
+    unless( defined $usable_regex ) {
+        local $Level = $Level + 1;
+        $ok = $self->ok( 0, $name );
+        $self->diag("    '$regex' doesn't look much like a regex to me.");
+        return $ok;
+    }
+
+    {
+        my $test;
+        my $context = $self->_caller_context;
+
+        {
+            ## no critic (BuiltinFunctions::ProhibitStringyEval)
+
+            local( $@, $!, $SIG{__DIE__} );    # isolate eval
+
+            # No point in issuing an uninit warning, they'll see it in the diagnostics
+            no warnings 'uninitialized';
+
+            $test = eval $context . q{$test = $thing =~ /$usable_regex/ ? 1 : 0};
+        }
+
+        $test = !$test if $cmp eq '!~';
+
+        local $Level = $Level + 1;
+        $ok = $self->ok( $test, $name );
+    }
+
+    unless($ok) {
+        $thing = defined $thing ? "'$thing'" : 'undef';
+        my $match = $cmp eq '=~' ? "doesn't match" : "matches";
+
+        local $Level = $Level + 1;
+        $self->diag( sprintf <<'DIAGNOSTIC', $thing, $match, $regex );
+                  %s
+    %13s '%s'
+DIAGNOSTIC
+
+    }
+
+    return $ok;
+}
+
+
+sub is_fh {
+    my $self     = shift;
+    my $maybe_fh = shift;
+    return 0 unless defined $maybe_fh;
+
+    return 1 if ref $maybe_fh  eq 'GLOB';    # its a glob ref
+    return 1 if ref \$maybe_fh eq 'GLOB';    # its a glob
+
+    return eval { $maybe_fh->isa("IO::Handle") } ||
+           eval { tied($maybe_fh)->can('TIEHANDLE') };
+}
+
+
+sub level {
+    my( $self, $level ) = @_;
+
+    if( defined $level ) {
+        $Level = $level;
+    }
+    return $Level;
+}
+
+
+sub use_numbers {
+    my( $self, $use_nums ) = @_;
+
+    my $ctx = $self->ctx;
+    my $format = $ctx->hub->format;
+    unless ($format && $format->can('no_numbers') && $format->can('set_no_numbers')) {
+        warn "The current formatter does not support 'use_numbers'" if $format;
+        return release $ctx, 0;
+    }
+
+    $format->set_no_numbers(!$use_nums) if defined $use_nums;
+
+    return release $ctx, $format->no_numbers ? 0 : 1;
+}
+
+BEGIN {
+    for my $method (qw(no_header no_diag)) {
+        my $set = "set_$method";
+        my $code = sub {
+            my( $self, $no ) = @_;
+
+            my $ctx = $self->ctx;
+            my $format = $ctx->hub->format;
+            unless ($format && $format->can($set)) {
+                warn "The current formatter does not support '$method'" if $format;
+                $ctx->release;
+                return
+            }
+
+            $format->$set($no) if defined $no;
+
+            return release $ctx, $format->$method ? 1 : 0;
+        };
+
+        no strict 'refs';    ## no critic
+        *$method = $code;
+    }
+}
+
+sub no_ending {
+    my( $self, $no ) = @_;
+
+    my $ctx = $self->ctx;
+
+    $ctx->hub->set_no_ending($no) if defined $no;
+
+    return release $ctx, $ctx->hub->no_ending;
+}
+
+sub diag {
+    my $self = shift;
+    return unless @_;
+
+    my $text = join '' => map {defined($_) ? $_ : 'undef'} @_;
+
+    if (Test2::API::test2_in_preload()) {
+        chomp($text);
+        $text =~ s/^/# /msg;
+        print STDERR $text, "\n";
+        return 0;
+    }
+
+    my $ctx = $self->ctx;
+    $ctx->diag($text);
+    $ctx->release;
+    return 0;
+}
+
+
+sub note {
+    my $self = shift;
+    return unless @_;
+
+    my $text = join '' => map {defined($_) ? $_ : 'undef'} @_;
+
+    if (Test2::API::test2_in_preload()) {
+        chomp($text);
+        $text =~ s/^/# /msg;
+        print STDOUT $text, "\n";
+        return 0;
+    }
+
+    my $ctx = $self->ctx;
+    $ctx->note($text);
+    $ctx->release;
+    return 0;
+}
+
+
+sub explain {
+    my $self = shift;
+
+    local ($@, $!);
+    require Data::Dumper;
+
+    return map {
+        ref $_
+          ? do {
+            my $dumper = Data::Dumper->new( [$_] );
+            $dumper->Indent(1)->Terse(1);
+            $dumper->Sortkeys(1) if $dumper->can("Sortkeys");
+            $dumper->Dump;
+          }
+          : $_
+    } @_;
+}
+
+
+sub output {
+    my( $self, $fh ) = @_;
+
+    my $ctx = $self->ctx;
+    my $format = $ctx->hub->format;
+    $ctx->release;
+    return unless $format && $format->isa('Test2::Formatter::TAP');
+
+    $format->handles->[Test2::Formatter::TAP::OUT_STD()] = $self->_new_fh($fh)
+        if defined $fh;
+
+    return $format->handles->[Test2::Formatter::TAP::OUT_STD()];
+}
+
+sub failure_output {
+    my( $self, $fh ) = @_;
+
+    my $ctx = $self->ctx;
+    my $format = $ctx->hub->format;
+    $ctx->release;
+    return unless $format && $format->isa('Test2::Formatter::TAP');
+
+    $format->handles->[Test2::Formatter::TAP::OUT_ERR()] = $self->_new_fh($fh)
+        if defined $fh;
+
+    return $format->handles->[Test2::Formatter::TAP::OUT_ERR()];
+}
+
+sub todo_output {
+    my( $self, $fh ) = @_;
+
+    my $ctx = $self->ctx;
+    my $format = $ctx->hub->format;
+    $ctx->release;
+    return unless $format && $format->isa('Test::Builder::Formatter');
+
+    $format->handles->[Test::Builder::Formatter::OUT_TODO()] = $self->_new_fh($fh)
+        if defined $fh;
+
+    return $format->handles->[Test::Builder::Formatter::OUT_TODO()];
+}
+
+sub _new_fh {
+    my $self = shift;
+    my ($file_or_fh) = shift;
+
+    my $fh;
+    if ($self->is_fh($file_or_fh)) {
+        $fh = $file_or_fh;
+    }
+    elsif (ref $file_or_fh eq 'SCALAR') {
+        open $fh, ">>", $file_or_fh
+            or $self->croak("Can't open scalar ref $file_or_fh: $!");
+    }
+    else {
+        open $fh, ">", $file_or_fh
+            or $self->croak("Can't open test output log $file_or_fh: $!");
+        _autoflush($fh);
+    }
+
+    return $fh;
+}
+
+sub _autoflush {
+    my($fh) = shift;
+    my $old_fh = select $fh;
+    $| = 1;
+    select $old_fh;
+
+    return;
+}
+
+
+sub reset_outputs {
+    my $self = shift;
+
+    my $ctx = $self->ctx;
+    my $format = $ctx->hub->format;
+    $ctx->release;
+    return unless $format && $format->isa('Test2::Formatter::TAP');
+    $format->set_handles([@{$self->{Orig_Handles}}]) if $self->{Orig_Handles};
+
+    return;
+}
+
+
+sub carp {
+    my $self = shift;
+    my $ctx = $self->ctx;
+    $ctx->alert(join "", @_);
+    $ctx->release;
+}
+
+sub croak {
+    my $self = shift;
+    my $ctx = $self->ctx;
+    $ctx->throw(join "", @_);
+    $ctx->release;
+}
+
+
+sub current_test {
+    my( $self, $num ) = @_;
+
+    my $ctx = $self->ctx;
+    my $hub = $ctx->hub;
+
+    if( defined $num ) {
+        $hub->set_count($num);
+
+        unless ($self->{no_log_results}) {
+            # If the test counter is being pushed forward fill in the details.
+            my $test_results = $ctx->hub->meta(__PACKAGE__, {})->{Test_Results};
+            if ($num > @$test_results) {
+                my $start = @$test_results ? @$test_results : 0;
+                for ($start .. $num - 1) {
+                    $test_results->[$_] = {
+                        'ok'      => 1,
+                        actual_ok => undef,
+                        reason    => 'incrementing test number',
+                        type      => 'unknown',
+                        name      => undef
+                    };
+                }
+            }
+            # If backward, wipe history.  Its their funeral.
+            elsif ($num < @$test_results) {
+                $#{$test_results} = $num - 1;
+            }
+        }
+    }
+    return release $ctx, $hub->count;
+}
+
+
+sub is_passing {
+    my $self = shift;
+
+    my $ctx = $self->ctx;
+    my $hub = $ctx->hub;
+
+    if( @_ ) {
+        my ($bool) = @_;
+        $hub->set_failed(0) if $bool;
+        $hub->is_passing($bool);
+    }
+
+    return release $ctx, $hub->is_passing;
+}
+
+
+sub summary {
+    my($self) = shift;
+
+    return if $self->{no_log_results};
+
+    my $ctx = $self->ctx;
+    my $data = $ctx->hub->meta(__PACKAGE__, {})->{Test_Results};
+    $ctx->release;
+    return map { $_ ? $_->{'ok'} : () } @$data;
+}
+
+
+sub details {
+    my $self = shift;
+
+    return if $self->{no_log_results};
+
+    my $ctx = $self->ctx;
+    my $data = $ctx->hub->meta(__PACKAGE__, {})->{Test_Results};
+    $ctx->release;
+    return @$data;
+}
+
+
+sub find_TODO {
+    my( $self, $pack, $set, $new_value ) = @_;
+
+    my $ctx = $self->ctx;
+
+    $pack ||= $ctx->trace->package || $self->exported_to;
+    $ctx->release;
+
+    return unless $pack;
+
+    no strict 'refs';    ## no critic
+    no warnings 'once';
+    my $old_value = ${ $pack . '::TODO' };
+    $set and ${ $pack . '::TODO' } = $new_value;
+    return $old_value;
+}
+
+sub todo {
+    my( $self, $pack ) = @_;
+
+    local $Level = $Level + 1;
+    my $ctx = $self->ctx;
+    $ctx->release;
+
+    my $meta = $ctx->hub->meta(__PACKAGE__, {todo => []})->{todo};
+    return $meta->[-1]->[1] if $meta && @$meta;
+
+    $pack ||= $ctx->trace->package;
+
+    return unless $pack;
+
+    no strict 'refs';    ## no critic
+    no warnings 'once';
+    return ${ $pack . '::TODO' };
+}
+
+sub in_todo {
+    my $self = shift;
+
+    local $Level = $Level + 1;
+    my $ctx = $self->ctx;
+    $ctx->release;
+
+    my $meta = $ctx->hub->meta(__PACKAGE__, {todo => []})->{todo};
+    return 1 if $meta && @$meta;
+
+    my $pack = $ctx->trace->package || return 0;
+
+    no strict 'refs';    ## no critic
+    no warnings 'once';
+    my $todo = ${ $pack . '::TODO' };
+
+    return 0 unless defined $todo;
+    return 0 if "$todo" eq '';
+    return 1;
+}
+
+sub todo_start {
+    my $self = shift;
+    my $message = @_ ? shift : '';
+
+    my $ctx = $self->ctx;
+
+    my $hub = $ctx->hub;
+    my $filter = $hub->pre_filter(sub {
+        my ($active_hub, $e) = @_;
+
+        # Turn a diag into a todo diag
+        return Test::Builder::TodoDiag->new(%$e) if ref($e) eq 'Test2::Event::Diag';
+
+        # Set todo on ok's
+        if ($hub == $active_hub && $e->isa('Test2::Event::Ok')) {
+            $e->set_todo($message);
+            $e->set_effective_pass(1);
+
+            if (my $result = $e->get_meta(__PACKAGE__)) {
+                $result->{reason} ||= $message;
+                $result->{type}   ||= 'todo';
+                $result->{ok}       = 1;
+            }
+        }
+
+        return $e;
+    }, inherit => 1);
+
+    push @{$ctx->hub->meta(__PACKAGE__, {todo => []})->{todo}} => [$filter, $message];
+
+    $ctx->release;
+
+    return;
+}
+
+sub todo_end {
+    my $self = shift;
+
+    my $ctx = $self->ctx;
+
+    my $set = pop @{$ctx->hub->meta(__PACKAGE__, {todo => []})->{todo}};
+
+    $ctx->throw('todo_end() called without todo_start()') unless $set;
+
+    $ctx->hub->pre_unfilter($set->[0]);
+
+    $ctx->release;
+
+    return;
+}
+
+
+sub caller {    ## no critic (Subroutines::ProhibitBuiltinHomonyms)
+    my( $self ) = @_;
+
+    my $ctx = $self->ctx;
+
+    my $trace = $ctx->trace;
+    $ctx->release;
+    return wantarray ? $trace->call : $trace->package;
+}
+
+
+sub _try {
+    my( $self, $code, %opts ) = @_;
+
+    my $error;
+    my $return;
+    {
+        local $!;               # eval can mess up $!
+        local $@;               # don't set $@ in the test
+        local $SIG{__DIE__};    # don't trip an outside DIE handler.
+        $return = eval { $code->() };
+        $error = $@;
+    }
+
+    die $error if $error and $opts{die_on_fail};
+
+    return wantarray ? ( $return, $error ) : $return;
+}
+
+sub _ending {
+    my $self = shift;
+    my ($ctx, $real_exit_code, $new) = @_;
+
+    unless ($ctx) {
+        my $octx = $self->ctx;
+        $ctx = $octx->snapshot;
+        $octx->release;
+    }
+
+    return if $ctx->hub->no_ending;
+    return if $ctx->hub->meta(__PACKAGE__, {})->{Ending}++;
+
+    # Don't bother with an ending if this is a forked copy.  Only the parent
+    # should do the ending.
+    return unless $self->{Original_Pid} == $$;
+
+    my $hub = $ctx->hub;
+    return if $hub->bailed_out;
+
+    my $plan  = $hub->plan;
+    my $count = $hub->count;
+    my $failed = $hub->failed;
+    my $passed = $hub->is_passing;
+    return unless $plan || $count || $failed;
+
+    # Ran tests but never declared a plan or hit done_testing
+    if( !defined($hub->plan) and $hub->count ) {
+        $self->diag("Tests were run but no plan was declared and done_testing() was not seen.");
+
+        if($real_exit_code) {
+            $self->diag(<<"FAIL");
+Looks like your test exited with $real_exit_code just after $count.
+FAIL
+            $$new ||= $real_exit_code;
+            return;
+        }
+
+        # But if the tests ran, handle exit code.
+        if($failed > 0) {
+            my $exit_code = $failed <= 254 ? $failed : 254;
+            $$new ||= $exit_code;
+            return;
+        }
+
+        $$new ||= 254;
+        return;
+    }
+
+    if ($real_exit_code && !$count) {
+        $self->diag("Looks like your test exited with $real_exit_code before it could output anything.");
+        $$new ||= $real_exit_code;
+        return;
+    }
+
+    return if $plan && "$plan" eq 'SKIP';
+
+    if (!$count) {
+        $self->diag('No tests run!');
+        $$new ||= 255;
+        return;
+    }
+
+    if ($real_exit_code) {
+        $self->diag(<<"FAIL");
+Looks like your test exited with $real_exit_code just after $count.
+FAIL
+        $$new ||= $real_exit_code;
+        return;
+    }
+
+    if ($plan eq 'NO PLAN') {
+        $ctx->plan( $count );
+        $plan = $hub->plan;
+    }
+
+    # Figure out if we passed or failed and print helpful messages.
+    my $num_extra = $count - $plan;
+
+    if ($num_extra != 0) {
+        my $s = $plan == 1 ? '' : 's';
+        $self->diag(<<"FAIL");
+Looks like you planned $plan test$s but ran $count.
+FAIL
+    }
+
+    if ($failed) {
+        my $s = $failed == 1 ? '' : 's';
+
+        my $qualifier = $num_extra == 0 ? '' : ' run';
+
+        $self->diag(<<"FAIL");
+Looks like you failed $failed test$s of $count$qualifier.
+FAIL
+    }
+
+    if (!$passed && !$failed && $count && !$num_extra) {
+        $ctx->diag(<<"FAIL");
+All assertions passed, but errors were encountered.
+FAIL
+    }
+
+    my $exit_code = 0;
+    if ($failed) {
+        $exit_code = $failed <= 254 ? $failed : 254;
+    }
+    elsif ($num_extra != 0) {
+        $exit_code = 255;
+    }
+    elsif (!$passed) {
+        $exit_code = 255;
+    }
+
+    $$new ||= $exit_code;
+    return;
+}
+
+# Some things used this even though it was private... I am looking at you
+# Test::Builder::Prefix...
+sub _print_comment {
+    my( $self, $fh, @msgs ) = @_;
+
+    return if $self->no_diag;
+    return unless @msgs;
+
+    # Prevent printing headers when compiling (i.e. -c)
+    return if $^C;
+
+    # Smash args together like print does.
+    # Convert undef to 'undef' so its readable.
+    my $msg = join '', map { defined($_) ? $_ : 'undef' } @msgs;
+
+    # Escape the beginning, _print will take care of the rest.
+    $msg =~ s/^/# /;
+
+    local( $\, $", $, ) = ( undef, ' ', '' );
+    print $fh $msg;
+
+    return 0;
+}
+
+# This is used by Test::SharedFork to turn on IPC after the fact. Not
+# documenting because I do not want it used. The method name is borrowed from
+# Test::Builder 2
+# Once Test2 stuff goes stable this method will be removed and Test::SharedFork
+# will be made smarter.
+sub coordinate_forks {
+    my $self = shift;
+
+    {
+        local ($@, $!);
+        require Test2::IPC;
+    }
+    Test2::IPC->import;
+    Test2::API::test2_ipc_enable_polling();
+    Test2::API::test2_load();
+    my $ipc = Test2::IPC::apply_ipc($self->{Stack});
+    $ipc->set_no_fatal(1);
+    Test2::API::test2_no_wait(1);
+}
+
+sub no_log_results { $_[0]->{no_log_results} = 1 }
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Builder - Backend for building test libraries
+
+=head1 SYNOPSIS
+
+  package My::Test::Module;
+  use base 'Test::Builder::Module';
+
+  my $CLASS = __PACKAGE__;
+
+  sub ok {
+      my($test, $name) = @_;
+      my $tb = $CLASS->builder;
+
+      $tb->ok($test, $name);
+  }
+
+
+=head1 DESCRIPTION
+
+L<Test::Simple> and L<Test::More> have proven to be popular testing modules,
+but they're not always flexible enough.  Test::Builder provides a
+building block upon which to write your own test libraries I<which can
+work together>.
+
+=head2 Construction
+
+=over 4
+
+=item B<new>
+
+  my $Test = Test::Builder->new;
+
+Returns a Test::Builder object representing the current state of the
+test.
+
+Since you only run one test per program C<new> always returns the same
+Test::Builder object.  No matter how many times you call C<new()>, you're
+getting the same object.  This is called a singleton.  This is done so that
+multiple modules share such global information as the test counter and
+where test output is going.
+
+If you want a completely new Test::Builder object different from the
+singleton, use C<create>.
+
+=item B<create>
+
+  my $Test = Test::Builder->create;
+
+Ok, so there can be more than one Test::Builder object and this is how
+you get it.  You might use this instead of C<new()> if you're testing
+a Test::Builder based module, but otherwise you probably want C<new>.
+
+B<NOTE>: the implementation is not complete.  C<level>, for example, is still
+shared by B<all> Test::Builder objects, even ones created using this method.
+Also, the method name may change in the future.
+
+=item B<subtest>
+
+    $builder->subtest($name, \&subtests, @args);
+
+See documentation of C<subtest> in Test::More.
+
+C<subtest> also, and optionally, accepts arguments which will be passed to the
+subtests reference.
+
+=item B<name>
+
+ diag $builder->name;
+
+Returns the name of the current builder.  Top level builders default to C<$0>
+(the name of the executable).  Child builders are named via the C<child>
+method.  If no name is supplied, will be named "Child of $parent->name".
+
+=item B<reset>
+
+  $Test->reset;
+
+Reinitializes the Test::Builder singleton to its original state.
+Mostly useful for tests run in persistent environments where the same
+test might be run multiple times in the same process.
+
+=back
+
+=head2 Setting up tests
+
+These methods are for setting up tests and declaring how many there
+are.  You usually only want to call one of these methods.
+
+=over 4
+
+=item B<plan>
+
+  $Test->plan('no_plan');
+  $Test->plan( skip_all => $reason );
+  $Test->plan( tests => $num_tests );
+
+A convenient way to set up your tests.  Call this and Test::Builder
+will print the appropriate headers and take the appropriate actions.
+
+If you call C<plan()>, don't call any of the other methods below.
+
+=item B<expected_tests>
+
+    my $max = $Test->expected_tests;
+    $Test->expected_tests($max);
+
+Gets/sets the number of tests we expect this test to run and prints out
+the appropriate headers.
+
+
+=item B<no_plan>
+
+  $Test->no_plan;
+
+Declares that this test will run an indeterminate number of tests.
+
+
+=item B<done_testing>
+
+  $Test->done_testing();
+  $Test->done_testing($num_tests);
+
+Declares that you are done testing, no more tests will be run after this point.
+
+If a plan has not yet been output, it will do so.
+
+$num_tests is the number of tests you planned to run.  If a numbered
+plan was already declared, and if this contradicts, a failing test
+will be run to reflect the planning mistake.  If C<no_plan> was declared,
+this will override.
+
+If C<done_testing()> is called twice, the second call will issue a
+failing test.
+
+If C<$num_tests> is omitted, the number of tests run will be used, like
+no_plan.
+
+C<done_testing()> is, in effect, used when you'd want to use C<no_plan>, but
+safer. You'd use it like so:
+
+    $Test->ok($a == $b);
+    $Test->done_testing();
+
+Or to plan a variable number of tests:
+
+    for my $test (@tests) {
+        $Test->ok($test);
+    }
+    $Test->done_testing(scalar @tests);
+
+
+=item B<has_plan>
+
+  $plan = $Test->has_plan
+
+Find out whether a plan has been defined. C<$plan> is either C<undef> (no plan
+has been set), C<no_plan> (indeterminate # of tests) or an integer (the number
+of expected tests).
+
+=item B<skip_all>
+
+  $Test->skip_all;
+  $Test->skip_all($reason);
+
+Skips all the tests, using the given C<$reason>.  Exits immediately with 0.
+
+=item B<exported_to>
+
+  my $pack = $Test->exported_to;
+  $Test->exported_to($pack);
+
+Tells Test::Builder what package you exported your functions to.
+
+This method isn't terribly useful since modules which share the same
+Test::Builder object might get exported to different packages and only
+the last one will be honored.
+
+=back
+
+=head2 Running tests
+
+These actually run the tests, analogous to the functions in Test::More.
+
+They all return true if the test passed, false if the test failed.
+
+C<$name> is always optional.
+
+=over 4
+
+=item B<ok>
+
+  $Test->ok($test, $name);
+
+Your basic test.  Pass if C<$test> is true, fail if $test is false.  Just
+like Test::Simple's C<ok()>.
+
+=item B<is_eq>
+
+  $Test->is_eq($got, $expected, $name);
+
+Like Test::More's C<is()>.  Checks if C<$got eq $expected>.  This is the
+string version.
+
+C<undef> only ever matches another C<undef>.
+
+=item B<is_num>
+
+  $Test->is_num($got, $expected, $name);
+
+Like Test::More's C<is()>.  Checks if C<$got == $expected>.  This is the
+numeric version.
+
+C<undef> only ever matches another C<undef>.
+
+=item B<isnt_eq>
+
+  $Test->isnt_eq($got, $dont_expect, $name);
+
+Like L<Test::More>'s C<isnt()>.  Checks if C<$got ne $dont_expect>.  This is
+the string version.
+
+=item B<isnt_num>
+
+  $Test->isnt_num($got, $dont_expect, $name);
+
+Like L<Test::More>'s C<isnt()>.  Checks if C<$got ne $dont_expect>.  This is
+the numeric version.
+
+=item B<like>
+
+  $Test->like($thing, qr/$regex/, $name);
+  $Test->like($thing, '/$regex/', $name);
+
+Like L<Test::More>'s C<like()>.  Checks if $thing matches the given C<$regex>.
+
+=item B<unlike>
+
+  $Test->unlike($thing, qr/$regex/, $name);
+  $Test->unlike($thing, '/$regex/', $name);
+
+Like L<Test::More>'s C<unlike()>.  Checks if $thing B<does not match> the
+given C<$regex>.
+
+=item B<cmp_ok>
+
+  $Test->cmp_ok($thing, $type, $that, $name);
+
+Works just like L<Test::More>'s C<cmp_ok()>.
+
+    $Test->cmp_ok($big_num, '!=', $other_big_num);
+
+=back
+
+=head2 Other Testing Methods
+
+These are methods which are used in the course of writing a test but are not themselves tests.
+
+=over 4
+
+=item B<BAIL_OUT>
+
+    $Test->BAIL_OUT($reason);
+
+Indicates to the L<Test::Harness> that things are going so badly all
+testing should terminate.  This includes running any additional test
+scripts.
+
+It will exit with 255.
+
+=for deprecated
+BAIL_OUT() used to be BAILOUT()
+
+=item B<skip>
+
+    $Test->skip;
+    $Test->skip($why);
+
+Skips the current test, reporting C<$why>.
+
+=item B<todo_skip>
+
+  $Test->todo_skip;
+  $Test->todo_skip($why);
+
+Like C<skip()>, only it will declare the test as failing and TODO.  Similar
+to
+
+    print "not ok $tnum # TODO $why\n";
+
+=begin _unimplemented
+
+=item B<skip_rest>
+
+  $Test->skip_rest;
+  $Test->skip_rest($reason);
+
+Like C<skip()>, only it skips all the rest of the tests you plan to run
+and terminates the test.
+
+If you're running under C<no_plan>, it skips once and terminates the
+test.
+
+=end _unimplemented
+
+=back
+
+
+=head2 Test building utility methods
+
+These methods are useful when writing your own test methods.
+
+=over 4
+
+=item B<maybe_regex>
+
+  $Test->maybe_regex(qr/$regex/);
+  $Test->maybe_regex('/$regex/');
+
+This method used to be useful back when Test::Builder worked on Perls
+before 5.6 which didn't have qr//.  Now its pretty useless.
+
+Convenience method for building testing functions that take regular
+expressions as arguments.
+
+Takes a quoted regular expression produced by C<qr//>, or a string
+representing a regular expression.
+
+Returns a Perl value which may be used instead of the corresponding
+regular expression, or C<undef> if its argument is not recognized.
+
+For example, a version of C<like()>, sans the useful diagnostic messages,
+could be written as:
+
+  sub laconic_like {
+      my ($self, $thing, $regex, $name) = @_;
+      my $usable_regex = $self->maybe_regex($regex);
+      die "expecting regex, found '$regex'\n"
+          unless $usable_regex;
+      $self->ok($thing =~ m/$usable_regex/, $name);
+  }
+
+
+=item B<is_fh>
+
+    my $is_fh = $Test->is_fh($thing);
+
+Determines if the given C<$thing> can be used as a filehandle.
+
+=cut
+
+
+=back
+
+
+=head2 Test style
+
+
+=over 4
+
+=item B<level>
+
+    $Test->level($how_high);
+
+How far up the call stack should C<$Test> look when reporting where the
+test failed.
+
+Defaults to 1.
+
+Setting C<$Test::Builder::Level> overrides.  This is typically useful
+localized:
+
+    sub my_ok {
+        my $test = shift;
+
+        local $Test::Builder::Level = $Test::Builder::Level + 1;
+        $TB->ok($test);
+    }
+
+To be polite to other functions wrapping your own you usually want to increment C<$Level> rather than set it to a constant.
+
+=item B<use_numbers>
+
+    $Test->use_numbers($on_or_off);
+
+Whether or not the test should output numbers.  That is, this if true:
+
+  ok 1
+  ok 2
+  ok 3
+
+or this if false
+
+  ok
+  ok
+  ok
+
+Most useful when you can't depend on the test output order, such as
+when threads or forking is involved.
+
+Defaults to on.
+
+=item B<no_diag>
+
+    $Test->no_diag($no_diag);
+
+If set true no diagnostics will be printed.  This includes calls to
+C<diag()>.
+
+=item B<no_ending>
+
+    $Test->no_ending($no_ending);
+
+Normally, Test::Builder does some extra diagnostics when the test
+ends.  It also changes the exit code as described below.
+
+If this is true, none of that will be done.
+
+=item B<no_header>
+
+    $Test->no_header($no_header);
+
+If set to true, no "1..N" header will be printed.
+
+=back
+
+=head2 Output
+
+Controlling where the test output goes.
+
+It's ok for your test to change where STDOUT and STDERR point to,
+Test::Builder's default output settings will not be affected.
+
+=over 4
+
+=item B<diag>
+
+    $Test->diag(@msgs);
+
+Prints out the given C<@msgs>.  Like C<print>, arguments are simply
+appended together.
+
+Normally, it uses the C<failure_output()> handle, but if this is for a
+TODO test, the C<todo_output()> handle is used.
+
+Output will be indented and marked with a # so as not to interfere
+with test output.  A newline will be put on the end if there isn't one
+already.
+
+We encourage using this rather than calling print directly.
+
+Returns false.  Why?  Because C<diag()> is often used in conjunction with
+a failing test (C<ok() || diag()>) it "passes through" the failure.
+
+    return ok(...) || diag(...);
+
+=for blame transfer
+Mark Fowler <mark@twoshortplanks.com>
+
+=item B<note>
+
+    $Test->note(@msgs);
+
+Like C<diag()>, but it prints to the C<output()> handle so it will not
+normally be seen by the user except in verbose mode.
+
+=item B<explain>
+
+    my @dump = $Test->explain(@msgs);
+
+Will dump the contents of any references in a human readable format.
+Handy for things like...
+
+    is_deeply($have, $want) || diag explain $have;
+
+or
+
+    is_deeply($have, $want) || note explain $have;
+
+=item B<output>
+
+=item B<failure_output>
+
+=item B<todo_output>
+
+    my $filehandle = $Test->output;
+    $Test->output($filehandle);
+    $Test->output($filename);
+    $Test->output(\$scalar);
+
+These methods control where Test::Builder will print its output.
+They take either an open C<$filehandle>, a C<$filename> to open and write to
+or a C<$scalar> reference to append to.  It will always return a C<$filehandle>.
+
+B<output> is where normal "ok/not ok" test output goes.
+
+Defaults to STDOUT.
+
+B<failure_output> is where diagnostic output on test failures and
+C<diag()> goes.  It is normally not read by Test::Harness and instead is
+displayed to the user.
+
+Defaults to STDERR.
+
+C<todo_output> is used instead of C<failure_output()> for the
+diagnostics of a failing TODO test.  These will not be seen by the
+user.
+
+Defaults to STDOUT.
+
+=item reset_outputs
+
+  $tb->reset_outputs;
+
+Resets all the output filehandles back to their defaults.
+
+=item carp
+
+  $tb->carp(@message);
+
+Warns with C<@message> but the message will appear to come from the
+point where the original test function was called (C<< $tb->caller >>).
+
+=item croak
+
+  $tb->croak(@message);
+
+Dies with C<@message> but the message will appear to come from the
+point where the original test function was called (C<< $tb->caller >>).
+
+
+=back
+
+
+=head2 Test Status and Info
+
+=over 4
+
+=item B<no_log_results>
+
+This will turn off result long-term storage. Calling this method will make
+C<details> and C<summary> useless. You may want to use this if you are running
+enough tests to fill up all available memory.
+
+    Test::Builder->new->no_log_results();
+
+There is no way to turn it back on.
+
+=item B<current_test>
+
+    my $curr_test = $Test->current_test;
+    $Test->current_test($num);
+
+Gets/sets the current test number we're on.  You usually shouldn't
+have to set this.
+
+If set forward, the details of the missing tests are filled in as 'unknown'.
+if set backward, the details of the intervening tests are deleted.  You
+can erase history if you really want to.
+
+
+=item B<is_passing>
+
+   my $ok = $builder->is_passing;
+
+Indicates if the test suite is currently passing.
+
+More formally, it will be false if anything has happened which makes
+it impossible for the test suite to pass.  True otherwise.
+
+For example, if no tests have run C<is_passing()> will be true because
+even though a suite with no tests is a failure you can add a passing
+test to it and start passing.
+
+Don't think about it too much.
+
+
+=item B<summary>
+
+    my @tests = $Test->summary;
+
+A simple summary of the tests so far.  True for pass, false for fail.
+This is a logical pass/fail, so todos are passes.
+
+Of course, test #1 is $tests[0], etc...
+
+
+=item B<details>
+
+    my @tests = $Test->details;
+
+Like C<summary()>, but with a lot more detail.
+
+    $tests[$test_num - 1] =
+            { 'ok'       => is the test considered a pass?
+              actual_ok  => did it literally say 'ok'?
+              name       => name of the test (if any)
+              type       => type of test (if any, see below).
+              reason     => reason for the above (if any)
+            };
+
+'ok' is true if Test::Harness will consider the test to be a pass.
+
+'actual_ok' is a reflection of whether or not the test literally
+printed 'ok' or 'not ok'.  This is for examining the result of 'todo'
+tests.
+
+'name' is the name of the test.
+
+'type' indicates if it was a special test.  Normal tests have a type
+of ''.  Type can be one of the following:
+
+    skip        see skip()
+    todo        see todo()
+    todo_skip   see todo_skip()
+    unknown     see below
+
+Sometimes the Test::Builder test counter is incremented without it
+printing any test output, for example, when C<current_test()> is changed.
+In these cases, Test::Builder doesn't know the result of the test, so
+its type is 'unknown'.  These details for these tests are filled in.
+They are considered ok, but the name and actual_ok is left C<undef>.
+
+For example "not ok 23 - hole count # TODO insufficient donuts" would
+result in this structure:
+
+    $tests[22] =    # 23 - 1, since arrays start from 0.
+      { ok        => 1,   # logically, the test passed since its todo
+        actual_ok => 0,   # in absolute terms, it failed
+        name      => 'hole count',
+        type      => 'todo',
+        reason    => 'insufficient donuts'
+      };
+
+
+=item B<todo>
+
+    my $todo_reason = $Test->todo;
+    my $todo_reason = $Test->todo($pack);
+
+If the current tests are considered "TODO" it will return the reason,
+if any.  This reason can come from a C<$TODO> variable or the last call
+to C<todo_start()>.
+
+Since a TODO test does not need a reason, this function can return an
+empty string even when inside a TODO block.  Use C<< $Test->in_todo >>
+to determine if you are currently inside a TODO block.
+
+C<todo()> is about finding the right package to look for C<$TODO> in.  It's
+pretty good at guessing the right package to look at.  It first looks for
+the caller based on C<$Level + 1>, since C<todo()> is usually called inside
+a test function.  As a last resort it will use C<exported_to()>.
+
+Sometimes there is some confusion about where C<todo()> should be looking
+for the C<$TODO> variable.  If you want to be sure, tell it explicitly
+what $pack to use.
+
+=item B<find_TODO>
+
+    my $todo_reason = $Test->find_TODO();
+    my $todo_reason = $Test->find_TODO($pack);
+
+Like C<todo()> but only returns the value of C<$TODO> ignoring
+C<todo_start()>.
+
+Can also be used to set C<$TODO> to a new value while returning the
+old value:
+
+    my $old_reason = $Test->find_TODO($pack, 1, $new_reason);
+
+=item B<in_todo>
+
+    my $in_todo = $Test->in_todo;
+
+Returns true if the test is currently inside a TODO block.
+
+=item B<todo_start>
+
+    $Test->todo_start();
+    $Test->todo_start($message);
+
+This method allows you declare all subsequent tests as TODO tests, up until
+the C<todo_end> method has been called.
+
+The C<TODO:> and C<$TODO> syntax is generally pretty good about figuring out
+whether or not we're in a TODO test.  However, often we find that this is not
+possible to determine (such as when we want to use C<$TODO> but
+the tests are being executed in other packages which can't be inferred
+beforehand).
+
+Note that you can use this to nest "todo" tests
+
+ $Test->todo_start('working on this');
+ # lots of code
+ $Test->todo_start('working on that');
+ # more code
+ $Test->todo_end;
+ $Test->todo_end;
+
+This is generally not recommended, but large testing systems often have weird
+internal needs.
+
+We've tried to make this also work with the TODO: syntax, but it's not
+guaranteed and its use is also discouraged:
+
+ TODO: {
+     local $TODO = 'We have work to do!';
+     $Test->todo_start('working on this');
+     # lots of code
+     $Test->todo_start('working on that');
+     # more code
+     $Test->todo_end;
+     $Test->todo_end;
+ }
+
+Pick one style or another of "TODO" to be on the safe side.
+
+
+=item C<todo_end>
+
+ $Test->todo_end;
+
+Stops running tests as "TODO" tests.  This method is fatal if called without a
+preceding C<todo_start> method call.
+
+=item B<caller>
+
+    my $package = $Test->caller;
+    my($pack, $file, $line) = $Test->caller;
+    my($pack, $file, $line) = $Test->caller($height);
+
+Like the normal C<caller()>, except it reports according to your C<level()>.
+
+C<$height> will be added to the C<level()>.
+
+If C<caller()> winds up off the top of the stack it report the highest context.
+
+=back
+
+=head1 EXIT CODES
+
+If all your tests passed, Test::Builder will exit with zero (which is
+normal).  If anything failed it will exit with how many failed.  If
+you run less (or more) tests than you planned, the missing (or extras)
+will be considered failures.  If no tests were ever run Test::Builder
+will throw a warning and exit with 255.  If the test died, even after
+having successfully completed all its tests, it will still be
+considered a failure and will exit with 255.
+
+So the exit codes are...
+
+    0                   all tests successful
+    255                 test died or all passed but wrong # of tests run
+    any other number    how many failed (including missing or extras)
+
+If you fail more than 254 tests, it will be reported as 254.
+
+=head1 THREADS
+
+In perl 5.8.1 and later, Test::Builder is thread-safe.  The test number is
+shared by all threads.  This means if one thread sets the test number using
+C<current_test()> they will all be affected.
+
+While versions earlier than 5.8.1 had threads they contain too many
+bugs to support.
+
+Test::Builder is only thread-aware if threads.pm is loaded I<before>
+Test::Builder.
+
+You can directly disable thread support with one of the following:
+
+    $ENV{T2_NO_IPC} = 1
+
+or
+
+    no Test2::IPC;
+
+or
+
+    Test2::API::test2_ipc_disable()
+
+=head1 MEMORY
+
+An informative hash, accessible via C<details()>, is stored for each
+test you perform.  So memory usage will scale linearly with each test
+run. Although this is not a problem for most test suites, it can
+become an issue if you do large (hundred thousands to million)
+combinatorics tests in the same run.
+
+In such cases, you are advised to either split the test file into smaller
+ones, or use a reverse approach, doing "normal" (code) compares and
+triggering C<fail()> should anything go unexpected.
+
+Future versions of Test::Builder will have a way to turn history off.
+
+
+=head1 EXAMPLES
+
+CPAN can provide the best examples.  L<Test::Simple>, L<Test::More>,
+L<Test::Exception> and L<Test::Differences> all use Test::Builder.
+
+=head1 SEE ALSO
+
+=head2 INTERNALS
+
+L<Test2>, L<Test2::API>
+
+=head2 LEGACY
+
+L<Test::Simple>, L<Test::More>
+
+=head2 EXTERNAL
+
+L<Test::Harness>
+
+=head1 AUTHORS
+
+Original code by chromatic, maintained by Michael G Schwern
+E<lt>schwern@pobox.comE<gt>
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2002-2008 by chromatic E<lt>chromatic@wgz.orgE<gt> and
+                       Michael G Schwern E<lt>schwern@pobox.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>

git/usr/share/perl5/core_perl/Test/Harness.pm

@@ -0,0 +1,611 @@
+package Test::Harness;
+
+use 5.006;
+
+use strict;
+use warnings;
+
+use constant IS_WIN32 => ( $^O =~ /^(MS)?Win32$/ );
+use constant IS_VMS => ( $^O eq 'VMS' );
+
+use TAP::Harness                     ();
+use TAP::Parser::Aggregator          ();
+use TAP::Parser::Source              ();
+use TAP::Parser::SourceHandler::Perl ();
+
+use Text::ParseWords qw(shellwords);
+
+use Config;
+use base 'Exporter';
+
+# $ML $Last_ML_Print
+
+BEGIN {
+    eval q{use Time::HiRes 'time'};
+    our $has_time_hires = !$@;
+}
+
+=head1 NAME
+
+Test::Harness - Run Perl standard test scripts with statistics
+
+=head1 VERSION
+
+Version 3.50
+
+=cut
+
+our $VERSION = '3.50';
+
+# Backwards compatibility for exportable variable names.
+*verbose  = *Verbose;
+*switches = *Switches;
+*debug    = *Debug;
+
+$ENV{HARNESS_ACTIVE}  = 1;
+$ENV{HARNESS_VERSION} = $VERSION;
+
+END {
+
+    # For VMS.
+    delete $ENV{HARNESS_ACTIVE};
+    delete $ENV{HARNESS_VERSION};
+}
+
+our @EXPORT    = qw(&runtests);
+our @EXPORT_OK = qw(&execute_tests $verbose $switches);
+
+our $Verbose = $ENV{HARNESS_VERBOSE} || 0;
+our $Debug   = $ENV{HARNESS_DEBUG}   || 0;
+our $Switches = '-w';
+our $Columns = $ENV{HARNESS_COLUMNS} || $ENV{COLUMNS} || 80;
+$Columns--;    # Some shells have trouble with a full line of text.
+our $Timer      = $ENV{HARNESS_TIMER}       || 0;
+our $Color      = $ENV{HARNESS_COLOR}       || 0;
+our $IgnoreExit = $ENV{HARNESS_IGNORE_EXIT} || 0;
+
+=head1 SYNOPSIS
+
+  use Test::Harness;
+
+  runtests(@test_files);
+
+=head1 DESCRIPTION
+
+Although, for historical reasons, the L<Test::Harness> distribution
+takes its name from this module it now exists only to provide
+L<TAP::Harness> with an interface that is somewhat backwards compatible
+with L<Test::Harness> 2.xx. If you're writing new code consider using
+L<TAP::Harness> directly instead.
+
+Emulation is provided for C<runtests> and C<execute_tests> but the
+pluggable 'Straps' interface that previous versions of L<Test::Harness>
+supported is not reproduced here. Straps is now available as a stand
+alone module: L<Test::Harness::Straps>.
+
+See L<TAP::Parser>, L<TAP::Harness> for the main documentation for this
+distribution.
+
+=head1 FUNCTIONS
+
+The following functions are available.
+
+=head2 runtests( @test_files )
+
+This runs all the given I<@test_files> and divines whether they passed
+or failed based on their output to STDOUT (details above).  It prints
+out each individual test which failed along with a summary report and
+a how long it all took.
+
+It returns true if everything was ok.  Otherwise it will C<die()> with
+one of the messages in the DIAGNOSTICS section.
+
+=cut
+
+sub _has_taint {
+    my $test = shift;
+    return TAP::Parser::SourceHandler::Perl->get_taint(
+        TAP::Parser::Source->shebang($test) );
+}
+
+sub _aggregate {
+    my ( $harness, $aggregate, @tests ) = @_;
+
+    # Don't propagate to our children
+    local $ENV{HARNESS_OPTIONS};
+
+    _apply_extra_INC($harness);
+    _aggregate_tests( $harness, $aggregate, @tests );
+}
+
+# Make sure the child sees all the extra junk in @INC
+sub _apply_extra_INC {
+    my $harness = shift;
+
+    $harness->callback(
+        parser_args => sub {
+            my ( $args, $test ) = @_;
+            push @{ $args->{switches} }, map {"-I$_"} _filtered_inc();
+        }
+    );
+}
+
+sub _aggregate_tests {
+    my ( $harness, $aggregate, @tests ) = @_;
+    $aggregate->start();
+    $harness->aggregate_tests( $aggregate, @tests );
+    $aggregate->stop();
+
+}
+
+sub runtests {
+    my @tests = @_;
+
+    # shield against -l
+    local ( $\, $, );
+
+    my $harness   = _new_harness();
+    local $ENV{PERL_USE_UNSAFE_INC} = 1 if not exists $ENV{PERL_USE_UNSAFE_INC};
+
+    # Don't propagate to our children
+    local $ENV{HARNESS_OPTIONS};
+    my $aggregate = $harness->runtests(@tests);
+
+    my $total  = $aggregate->total;
+    my $passed = $aggregate->passed;
+    my $failed = $aggregate->failed;
+    my $total_files = $aggregate->total_files;
+    my $failed_files = $aggregate->failed_files;
+
+    die(sprintf(
+            "Failed %d/%d test programs. %d/%d subtests failed.\n",
+            $failed_files, $total_files, $failed, $total
+        )
+    ) if $failed_files;
+
+    return $total && $total == $passed;
+}
+
+sub _canon {
+    my @list   = sort { $a <=> $b } @_;
+    my @ranges = ();
+    my $count  = scalar @list;
+    my $pos    = 0;
+
+    while ( $pos < $count ) {
+        my $end = $pos + 1;
+        $end++ while $end < $count && $list[$end] <= $list[ $end - 1 ] + 1;
+        push @ranges, ( $end == $pos + 1 )
+          ? $list[$pos]
+          : join( '-', $list[$pos], $list[ $end - 1 ] );
+        $pos = $end;
+    }
+
+    return join( ' ', @ranges );
+}
+
+sub _new_harness {
+    my $sub_args = shift || {};
+
+    my ( @lib, @switches );
+    my @opt = map { shellwords($_) } grep { defined } $Switches, $ENV{HARNESS_PERL_SWITCHES};
+    while ( my $opt = shift @opt ) {
+        if ( $opt =~ /^ -I (.*) $ /x ) {
+            push @lib, length($1) ? $1 : shift @opt;
+        }
+        else {
+            push @switches, $opt;
+        }
+    }
+
+    push @lib, _filtered_inc();
+
+    # If $Verbose isn't numeric default to 1. This helps core.
+    my $verbosity = ( $Verbose ? ( $Verbose !~ /\d/ ) ? 1 : $Verbose : 0 );
+
+    my $args = {
+        timer       => $Timer,
+        directives  => our $Directives,
+        lib         => \@lib,
+        switches    => \@switches,
+        color       => $Color,
+        verbosity   => $verbosity,
+        ignore_exit => $IgnoreExit,
+    };
+
+    $args->{stdout} = $sub_args->{out}
+      if exists $sub_args->{out};
+
+    my $class = $ENV{HARNESS_SUBCLASS} || 'TAP::Harness';
+    if ( defined( my $env_opt = $ENV{HARNESS_OPTIONS} ) ) {
+        for my $opt ( split /:/, $env_opt ) {
+            if ( $opt =~ /^j(\d*)$/ ) {
+                $args->{jobs} = $1 || 9;
+            }
+            elsif ( $opt eq 'c' ) {
+                $args->{color} = 1;
+            }
+            elsif ( $opt =~ m/^f(.*)$/ ) {
+                my $fmt = $1;
+                $fmt =~ s/-/::/g;
+                $args->{formatter_class} = $fmt;
+            }
+            elsif ( $opt =~ m/^a(.*)$/ ) {
+                my $archive = $1;
+                $class = "TAP::Harness::Archive";
+                $args->{archive} = $archive;
+            }
+            else {
+                die "Unknown HARNESS_OPTIONS item: $opt\n";
+            }
+        }
+    }
+
+    return TAP::Harness->_construct( $class, $args );
+}
+
+# Get the parts of @INC which are changed from the stock list AND
+# preserve reordering of stock directories.
+sub _filtered_inc {
+    my @inc = grep { !ref } @INC;    #28567
+
+    if (IS_VMS) {
+
+        # VMS has a 255-byte limit on the length of %ENV entries, so
+        # toss the ones that involve perl_root, the install location
+        @inc = grep !/perl_root/i, @inc;
+
+    }
+    elsif (IS_WIN32) {
+
+        # Lose any trailing backslashes in the Win32 paths
+        s/[\\\/]+$// for @inc;
+    }
+
+    my @default_inc = _default_inc();
+
+    my @new_inc;
+    my %seen;
+    for my $dir (@inc) {
+        next if $seen{$dir}++;
+
+        if ( $dir eq ( $default_inc[0] || '' ) ) {
+            shift @default_inc;
+        }
+        else {
+            push @new_inc, $dir;
+        }
+
+        shift @default_inc while @default_inc and $seen{ $default_inc[0] };
+    }
+
+    return @new_inc;
+}
+
+{
+
+    # Cache this to avoid repeatedly shelling out to Perl.
+    my @inc;
+
+    sub _default_inc {
+        return @inc if @inc;
+
+        local $ENV{PERL5LIB};
+        local $ENV{PERLLIB};
+
+        my $perl = $ENV{HARNESS_PERL} || $^X;
+
+        # Avoid using -l for the benefit of Perl 6
+        chomp( @inc = `"$perl" -e "print join qq[\\n], \@INC, q[]"` );
+        return @inc;
+    }
+}
+
+sub _check_sequence {
+    my @list = @_;
+    my $prev;
+    while ( my $next = shift @list ) {
+        return if defined $prev && $next <= $prev;
+        $prev = $next;
+    }
+
+    return 1;
+}
+
+sub execute_tests {
+    my %args = @_;
+
+    my $harness   = _new_harness( \%args );
+    my $aggregate = TAP::Parser::Aggregator->new();
+
+    my %tot = (
+        bonus       => 0,
+        max         => 0,
+        ok          => 0,
+        bad         => 0,
+        good        => 0,
+        files       => 0,
+        tests       => 0,
+        sub_skipped => 0,
+        todo        => 0,
+        skipped     => 0,
+        bench       => undef,
+    );
+
+    # Install a callback so we get to see any plans the
+    # harness executes.
+    $harness->callback(
+        made_parser => sub {
+            my $parser = shift;
+            $parser->callback(
+                plan => sub {
+                    my $plan = shift;
+                    if ( $plan->directive eq 'SKIP' ) {
+                        $tot{skipped}++;
+                    }
+                }
+            );
+        }
+    );
+
+    local $ENV{PERL_USE_UNSAFE_INC} = 1 if not exists $ENV{PERL_USE_UNSAFE_INC};
+    _aggregate( $harness, $aggregate, @{ $args{tests} } );
+
+    $tot{bench} = $aggregate->elapsed;
+    my @tests = $aggregate->descriptions;
+
+    # TODO: Work out the circumstances under which the files
+    # and tests totals can differ.
+    $tot{files} = $tot{tests} = scalar @tests;
+
+    my %failedtests = ();
+    my %todo_passed = ();
+
+    for my $test (@tests) {
+        my ($parser) = $aggregate->parsers($test);
+
+        my @failed = $parser->failed;
+
+        my $wstat         = $parser->wait;
+        my $estat         = $parser->exit;
+        my $planned       = $parser->tests_planned;
+        my @errors        = $parser->parse_errors;
+        my $passed        = $parser->passed;
+        my $actual_passed = $parser->actual_passed;
+
+        my $ok_seq = _check_sequence( $parser->actual_passed );
+
+        # Duplicate exit, wait status semantics of old version
+        $estat ||= '' unless $wstat;
+        $wstat ||= '';
+
+        $tot{max} += ( $planned || 0 );
+        $tot{bonus} += $parser->todo_passed;
+        $tot{ok} += $passed > $actual_passed ? $passed : $actual_passed;
+        $tot{sub_skipped} += $parser->skipped;
+        $tot{todo}        += $parser->todo;
+
+        if ( @failed || $estat || @errors ) {
+            $tot{bad}++;
+
+            my $huh_planned = $planned ? undef : '??';
+            my $huh_errors  = $ok_seq  ? undef : '??';
+
+            $failedtests{$test} = {
+                'canon' => $huh_planned
+                  || $huh_errors
+                  || _canon(@failed)
+                  || '??',
+                'estat'  => $estat,
+                'failed' => $huh_planned
+                  || $huh_errors
+                  || scalar @failed,
+                'max' => $huh_planned || $planned,
+                'name'  => $test,
+                'wstat' => $wstat
+            };
+        }
+        else {
+            $tot{good}++;
+        }
+
+        my @todo = $parser->todo_passed;
+        if (@todo) {
+            $todo_passed{$test} = {
+                'canon'  => _canon(@todo),
+                'estat'  => $estat,
+                'failed' => scalar @todo,
+                'max'    => scalar $parser->todo,
+                'name'   => $test,
+                'wstat'  => $wstat
+            };
+        }
+    }
+
+    return ( \%tot, \%failedtests, \%todo_passed );
+}
+
+=head2 execute_tests( tests => \@test_files, out => \*FH )
+
+Runs all the given C<@test_files> (just like C<runtests()>) but
+doesn't generate the final report.  During testing, progress
+information will be written to the currently selected output
+filehandle (usually C<STDOUT>), or to the filehandle given by the
+C<out> parameter.  The I<out> is optional.
+
+Returns a list of two values, C<$total> and C<$failed>, describing the
+results.  C<$total> is a hash ref summary of all the tests run.  Its
+keys and values are this:
+
+    bonus           Number of individual todo tests unexpectedly passed
+    max             Number of individual tests ran
+    ok              Number of individual tests passed
+    sub_skipped     Number of individual tests skipped
+    todo            Number of individual todo tests
+
+    files           Number of test files ran
+    good            Number of test files passed
+    bad             Number of test files failed
+    tests           Number of test files originally given
+    skipped         Number of test files skipped
+
+If C<< $total->{bad} == 0 >> and C<< $total->{max} > 0 >>, you've
+got a successful test.
+
+C<$failed> is a hash ref of all the test scripts that failed.  Each key
+is the name of a test script, each value is another hash representing
+how that script failed.  Its keys are these:
+
+    name        Name of the test which failed
+    estat       Script's exit value
+    wstat       Script's wait status
+    max         Number of individual tests
+    failed      Number which failed
+    canon       List of tests which failed (as string).
+
+C<$failed> should be empty if everything passed.
+
+=cut
+
+1;
+__END__
+
+=head1 EXPORT
+
+C<&runtests> is exported by C<Test::Harness> by default.
+
+C<&execute_tests>, C<$verbose>, C<$switches> and C<$debug> are
+exported upon request.
+
+=head1 ENVIRONMENT VARIABLES THAT TAP::HARNESS::COMPATIBLE SETS
+
+C<Test::Harness> sets these before executing the individual tests.
+
+=over 4
+
+=item C<HARNESS_ACTIVE>
+
+This is set to a true value.  It allows the tests to determine if they
+are being executed through the harness or by any other means.
+
+=item C<HARNESS_VERSION>
+
+This is the version of C<Test::Harness>.
+
+=back
+
+=head1 ENVIRONMENT VARIABLES THAT AFFECT TEST::HARNESS
+
+=over 4
+
+=item C<HARNESS_PERL_SWITCHES>
+
+Setting this adds perl command line switches to each test file run.
+
+For example, C<HARNESS_PERL_SWITCHES=-T> will turn on taint mode.
+C<HARNESS_PERL_SWITCHES=-MDevel::Cover> will run C<Devel::Cover> for
+each test.
+
+C<-w> is always set.  You can turn this off in the test with C<BEGIN {
+$^W = 0 }>.
+
+=item C<HARNESS_TIMER>
+
+Setting this to true will make the harness display the number of
+milliseconds each test took.  You can also use F<prove>'s C<--timer>
+switch.
+
+=item C<HARNESS_VERBOSE>
+
+If true, C<Test::Harness> will output the verbose results of running
+its tests.  Setting C<$Test::Harness::verbose> will override this,
+or you can use the C<-v> switch in the F<prove> utility.
+
+=item C<HARNESS_OPTIONS>
+
+Provide additional options to the harness. Currently supported options are:
+
+=over
+
+=item C<< j<n> >>
+
+Run <n> (default 9) parallel jobs.
+
+=item C<< c >>
+
+Try to color output. See L<TAP::Formatter::Base/"new">.
+
+=item C<< a<file.tgz> >>
+
+Will use L<TAP::Harness::Archive> as the harness class, and save the TAP to
+C<file.tgz>
+
+=item C<< fPackage-With-Dashes >>
+
+Set the formatter_class of the harness being run. Since the C<HARNESS_OPTIONS>
+is separated by C<:>, we use C<-> instead.
+
+=back
+
+Multiple options may be separated by colons:
+
+    HARNESS_OPTIONS=j9:c make test
+
+=item C<HARNESS_SUBCLASS>
+
+Specifies a TAP::Harness subclass to be used in place of TAP::Harness.
+
+=item C<HARNESS_SUMMARY_COLOR_SUCCESS>
+
+Determines the L<Term::ANSIColor> for the summary in case it is successful.
+This color defaults to C<'green'>.
+
+=item C<HARNESS_SUMMARY_COLOR_FAIL>
+
+Determines the L<Term::ANSIColor> for the failure in case it is successful.
+This color defaults to C<'red'>.
+
+=back
+
+=head1 Taint Mode
+
+Normally when a Perl program is run in taint mode the contents of the
+C<PERL5LIB> environment variable do not appear in C<@INC>.
+
+Because C<PERL5LIB> is often used during testing to add build
+directories to C<@INC> C<Test::Harness> passes the names of any
+directories found in C<PERL5LIB> as -I switches. The net effect of this
+is that C<PERL5LIB> is honoured even in taint mode.
+
+=head1 SEE ALSO
+
+L<TAP::Harness>
+
+=head1 BUGS
+
+Please report any bugs or feature requests to
+C<bug-test-harness at rt.cpan.org>, or through the web interface at
+L<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Test-Harness>.  I will be 
+notified, and then you'll automatically be notified of progress on your bug 
+as I make changes.
+
+=head1 AUTHORS
+
+Andy Armstrong  C<< <andy@hexten.net> >>
+
+L<Test::Harness> 2.64 (maintained by Andy Lester and on which this
+module is based) has this attribution:
+
+    Either Tim Bunce or Andreas Koenig, we don't know. What we know for
+    sure is, that it was inspired by Larry Wall's F<TEST> script that came
+    with perl distributions for ages. Numerous anonymous contributors
+    exist.  Andreas Koenig held the torch for many years, and then
+    Michael G Schwern.
+
+=head1 LICENCE AND COPYRIGHT
+
+Copyright (c) 2007-2011, Andy Armstrong C<< <andy@hexten.net> >>. All rights reserved.
+
+This module is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself. See L<perlartistic>.
+

git/usr/share/perl5/core_perl/Test/More.pm

@@ -0,0 +1,2047 @@
+package Test::More;
+
+use 5.006;
+use strict;
+use warnings;
+
+#---- perlcritic exemptions. ----#
+
+# We use a lot of subroutine prototypes
+## no critic (Subroutines::ProhibitSubroutinePrototypes)
+
+# Can't use Carp because it might cause C<use_ok()> to accidentally succeed
+# even though the module being used forgot to use Carp.  Yes, this
+# actually happened.
+sub _carp {
+    my( $file, $line ) = ( caller(1) )[ 1, 2 ];
+    return warn @_, " at $file line $line\n";
+}
+
+our $VERSION = '1.302210';
+
+use Test::Builder::Module;
+our @ISA    = qw(Test::Builder::Module);
+our @EXPORT = qw(ok use_ok require_ok
+  is isnt like unlike is_deeply
+  cmp_ok
+  skip todo todo_skip
+  pass fail
+  eq_array eq_hash eq_set
+  $TODO
+  plan
+  done_testing
+  can_ok isa_ok new_ok
+  diag note explain
+  subtest
+  BAIL_OUT
+);
+
+=head1 NAME
+
+Test::More - yet another framework for writing test scripts
+
+=head1 SYNOPSIS
+
+  use Test::More tests => 23;
+  # or
+  use Test::More skip_all => $reason;
+  # or
+  use Test::More;   # see done_testing()
+
+  require_ok( 'Some::Module' );
+
+  # Various ways to say "ok"
+  ok($got eq $expected, $test_name);
+
+  is  ($got, $expected, $test_name);
+  isnt($got, $expected, $test_name);
+
+  # Rather than print STDERR "# here's what went wrong\n"
+  diag("here's what went wrong");
+
+  like  ($got, qr/expected/, $test_name);
+  unlike($got, qr/expected/, $test_name);
+
+  cmp_ok($got, '==', $expected, $test_name);
+
+  is_deeply($got_complex_structure, $expected_complex_structure, $test_name);
+
+  SKIP: {
+      skip $why, $how_many unless $have_some_feature;
+
+      ok( foo(),       $test_name );
+      is( foo(42), 23, $test_name );
+  };
+
+  TODO: {
+      local $TODO = $why;
+
+      ok( foo(),       $test_name );
+      is( foo(42), 23, $test_name );
+  };
+
+  can_ok($module, @methods);
+  isa_ok($object, $class);
+
+  pass($test_name);
+  fail($test_name);
+
+  BAIL_OUT($why);
+
+  # UNIMPLEMENTED!!!
+  my @status = Test::More::status;
+
+
+=head1 DESCRIPTION
+
+B<STOP!> If you're just getting started writing tests, have a look at
+L<Test2::Suite> first.
+
+This is a drop in replacement for Test::Simple which you can switch to once you
+get the hang of basic testing.
+
+The purpose of this module is to provide a wide range of testing
+utilities.  Various ways to say "ok" with better diagnostics,
+facilities to skip tests, test future features and compare complicated
+data structures.  While you can do almost anything with a simple
+C<ok()> function, it doesn't provide good diagnostic output.
+
+
+=head2 I love it when a plan comes together
+
+Before anything else, you need a testing plan.  This basically declares
+how many tests your script is going to run to protect against premature
+failure.
+
+The preferred way to do this is to declare a plan when you C<use Test::More>.
+
+  use Test::More tests => 23;
+
+There are cases when you will not know beforehand how many tests your
+script is going to run.  In this case, you can declare your tests at
+the end.
+
+  use Test::More;
+
+  ... run your tests ...
+
+  done_testing( $number_of_tests_run );
+
+B<NOTE> C<done_testing()> should never be called in an C<END { ... }> block.
+
+Sometimes you really don't know how many tests were run, or it's too
+difficult to calculate.  In which case you can leave off
+$number_of_tests_run.
+
+In some cases, you'll want to completely skip an entire testing script.
+
+  use Test::More skip_all => $skip_reason;
+
+Your script will declare a skip with the reason why you skipped and
+exit immediately with a zero (success).  See L<Test::Harness> for
+details.
+
+If you want to control what functions Test::More will export, you
+have to use the 'import' option.  For example, to import everything
+but 'fail', you'd do:
+
+  use Test::More tests => 23, import => ['!fail'];
+
+Alternatively, you can use the C<plan()> function.  Useful for when you
+have to calculate the number of tests.
+
+  use Test::More;
+  plan tests => keys %Stuff * 3;
+
+or for deciding between running the tests at all:
+
+  use Test::More;
+  if( $^O eq 'MacOS' ) {
+      plan skip_all => 'Test irrelevant on MacOS';
+  }
+  else {
+      plan tests => 42;
+  }
+
+=cut
+
+sub plan {
+    my $tb = Test::More->builder;
+
+    return $tb->plan(@_);
+}
+
+# This implements "use Test::More 'no_diag'" but the behavior is
+# deprecated.
+sub import_extra {
+    my $class = shift;
+    my $list  = shift;
+
+    my @other;
+    my $idx   = 0;
+    my $import;
+    while( $idx <= $#{$list} ) {
+        my $item = $list->[$idx];
+
+        if( defined $item and $item eq 'no_diag' ) {
+            $class->builder->no_diag(1);
+        }
+        elsif( defined $item and $item eq 'import' ) {
+            if ($import) {
+                push @$import, @{$list->[ ++$idx ]};
+            }
+            else {
+                $import = $list->[ ++$idx ];
+                push @other, $item, $import;
+            }
+        }
+        else {
+            push @other, $item;
+        }
+
+        $idx++;
+    }
+
+    @$list = @other;
+
+    if ($class eq __PACKAGE__ && (!$import || grep $_ eq '$TODO', @$import)) {
+        my $to = $class->builder->exported_to;
+        no strict 'refs';
+        *{"$to\::TODO"} = \our $TODO;
+        if ($import) {
+            @$import = grep $_ ne '$TODO', @$import;
+        }
+        else {
+            push @$list, import => [grep $_ ne '$TODO', @EXPORT];
+        }
+    }
+
+    return;
+}
+
+=over 4
+
+=item B<done_testing>
+
+    done_testing();
+    done_testing($number_of_tests);
+
+If you don't know how many tests you're going to run, you can issue
+the plan when you're done running tests.
+
+$number_of_tests is the same as C<plan()>, it's the number of tests you
+expected to run.  You can omit this, in which case the number of tests
+you ran doesn't matter, just the fact that your tests ran to
+conclusion.
+
+This is safer than and replaces the "no_plan" plan.
+
+B<Note:> You must never put C<done_testing()> inside an C<END { ... }> block.
+The plan is there to ensure your test does not exit before testing has
+completed. If you use an END block you completely bypass this protection.
+
+=back
+
+=cut
+
+sub done_testing {
+    my $tb = Test::More->builder;
+    $tb->done_testing(@_);
+}
+
+=head2 Test names
+
+By convention, each test is assigned a number in order.  This is
+largely done automatically for you.  However, it's often very useful to
+assign a name to each test.  Which would you rather see:
+
+  ok 4
+  not ok 5
+  ok 6
+
+or
+
+  ok 4 - basic multi-variable
+  not ok 5 - simple exponential
+  ok 6 - force == mass * acceleration
+
+The later gives you some idea of what failed.  It also makes it easier
+to find the test in your script, simply search for "simple
+exponential".
+
+All test functions take a name argument.  It's optional, but highly
+suggested that you use it.
+
+=head2 I'm ok, you're not ok.
+
+The basic purpose of this module is to print out either "ok #" or "not
+ok #" depending on if a given test succeeded or failed.  Everything
+else is just gravy.
+
+All of the following print "ok" or "not ok" depending on if the test
+succeeded or failed.  They all also return true or false,
+respectively.
+
+=over 4
+
+=item B<ok>
+
+  ok($got eq $expected, $test_name);
+
+This simply evaluates any expression (C<$got eq $expected> is just a
+simple example) and uses that to determine if the test succeeded or
+failed.  A true expression passes, a false one fails.  Very simple.
+
+For example:
+
+    ok( $exp{9} == 81,                   'simple exponential' );
+    ok( Film->can('db_Main'),            'set_db()' );
+    ok( $p->tests == 4,                  'saw tests' );
+    ok( !grep(!defined $_, @items),      'all items defined' );
+
+(Mnemonic:  "This is ok.")
+
+$test_name is a very short description of the test that will be printed
+out.  It makes it very easy to find a test in your script when it fails
+and gives others an idea of your intentions.  $test_name is optional,
+but we B<very> strongly encourage its use.
+
+Should an C<ok()> fail, it will produce some diagnostics:
+
+    not ok 18 - sufficient mucus
+    #   Failed test 'sufficient mucus'
+    #   in foo.t at line 42.
+
+This is the same as L<Test::Simple>'s C<ok()> routine.
+
+=cut
+
+sub ok ($;$) {
+    my( $test, $name ) = @_;
+    my $tb = Test::More->builder;
+
+    return $tb->ok( $test, $name );
+}
+
+=item B<is>
+
+=item B<isnt>
+
+  is  ( $got, $expected, $test_name );
+  isnt( $got, $expected, $test_name );
+
+Similar to C<ok()>, C<is()> and C<isnt()> compare their two arguments
+with C<eq> and C<ne> respectively and use the result of that to
+determine if the test succeeded or failed.  So these:
+
+    # Is the ultimate answer 42?
+    is( ultimate_answer(), 42,          "Meaning of Life" );
+
+    # $foo isn't empty
+    isnt( $foo, '',     "Got some foo" );
+
+are similar to these:
+
+    ok( ultimate_answer() eq 42,        "Meaning of Life" );
+    ok( $foo ne '',     "Got some foo" );
+
+C<undef> will only ever match C<undef>.  So you can test a value
+against C<undef> like this:
+
+    is($not_defined, undef, "undefined as expected");
+
+(Mnemonic:  "This is that."  "This isn't that.")
+
+So why use these?  They produce better diagnostics on failure.  C<ok()>
+cannot know what you are testing for (beyond the name), but C<is()> and
+C<isnt()> know what the test was and why it failed.  For example this
+test:
+
+    my $foo = 'waffle';  my $bar = 'yarblokos';
+    is( $foo, $bar,   'Is foo the same as bar?' );
+
+Will produce something like this:
+
+    not ok 17 - Is foo the same as bar?
+    #   Failed test 'Is foo the same as bar?'
+    #   in foo.t at line 139.
+    #          got: 'waffle'
+    #     expected: 'yarblokos'
+
+So you can figure out what went wrong without rerunning the test.
+
+You are encouraged to use C<is()> and C<isnt()> over C<ok()> where possible,
+however do not be tempted to use them to find out if something is
+true or false!
+
+  # XXX BAD!
+  is( exists $brooklyn{tree}, 1, 'A tree grows in Brooklyn' );
+
+This does not check if C<exists $brooklyn{tree}> is true, it checks if
+it returns 1.  Very different.  Similar caveats exist for false and 0.
+In these cases, use C<ok()>.
+
+  ok( exists $brooklyn{tree},    'A tree grows in Brooklyn' );
+
+A simple call to C<isnt()> usually does not provide a strong test but there
+are cases when you cannot say much more about a value than that it is
+different from some other value:
+
+  new_ok $obj, "Foo";
+
+  my $clone = $obj->clone;
+  isa_ok $obj, "Foo", "Foo->clone";
+
+  isnt $obj, $clone, "clone() produces a different object";
+
+Historically we supported an C<isn't()> function as an alias of
+C<isnt()>, however in Perl 5.37.9 support for the use of apostrophe as
+a package separator was deprecated and by Perl 5.42.0 support for it
+will have been removed completely. Accordingly use of C<isn't()> is also
+deprecated, and will produce warnings when used unless 'deprecated'
+warnings are specifically disabled in the scope where it is used. You
+are strongly advised to migrate to using C<isnt()> instead.
+
+=cut
+
+sub is ($$;$) {
+    my $tb = Test::More->builder;
+
+    return $tb->is_eq(@_);
+}
+
+sub isnt ($$;$) {
+    my $tb = Test::More->builder;
+
+    return $tb->isnt_eq(@_);
+}
+
+# Historically it was possible to use apostrophes as a package
+# separator. make this available as isn't() for perl's that support it.
+# However in 5.37.9 the apostrophe as a package separator was
+# deprecated, so warn users of isn't() that they should use isnt()
+# instead. We assume that if they are calling isn::t() they are doing so
+# via isn't() as we have no way to be sure that they aren't spelling it
+# with a double colon. We only trigger the warning if deprecation
+# warnings are enabled, so the user can silence the warning if they
+# wish.
+sub isn::t {
+    local ($@, $!, $?);
+    if (warnings::enabled("deprecated")) {
+        _carp
+        "Use of apostrophe as package separator was deprecated in Perl 5.37.9,\n",
+        "and will be removed in Perl 5.42.0.  You should change code that uses\n",
+        "Test::More::isn't() to use Test::More::isnt() as a replacement";
+    }
+    goto &isnt;
+}
+
+=item B<like>
+
+  like( $got, qr/expected/, $test_name );
+
+Similar to C<ok()>, C<like()> matches $got against the regex C<qr/expected/>.
+
+So this:
+
+    like($got, qr/expected/, 'this is like that');
+
+is similar to:
+
+    ok( $got =~ m/expected/, 'this is like that');
+
+(Mnemonic "This is like that".)
+
+The second argument is a regular expression.  It may be given as a
+regex reference (i.e. C<qr//>) or (for better compatibility with older
+perls) as a string that looks like a regex (alternative delimiters are
+currently not supported):
+
+    like( $got, '/expected/', 'this is like that' );
+
+Regex options may be placed on the end (C<'/expected/i'>).
+
+Its advantages over C<ok()> are similar to that of C<is()> and C<isnt()>.  Better
+diagnostics on failure.
+
+=cut
+
+sub like ($$;$) {
+    my $tb = Test::More->builder;
+
+    return $tb->like(@_);
+}
+
+=item B<unlike>
+
+  unlike( $got, qr/expected/, $test_name );
+
+Works exactly as C<like()>, only it checks if $got B<does not> match the
+given pattern.
+
+=cut
+
+sub unlike ($$;$) {
+    my $tb = Test::More->builder;
+
+    return $tb->unlike(@_);
+}
+
+=item B<cmp_ok>
+
+  cmp_ok( $got, $op, $expected, $test_name );
+
+Halfway between C<ok()> and C<is()> lies C<cmp_ok()>.  This allows you
+to compare two arguments using any binary perl operator.  The test
+passes if the comparison is true and fails otherwise.
+
+    # ok( $got eq $expected );
+    cmp_ok( $got, 'eq', $expected, 'this eq that' );
+
+    # ok( $got == $expected );
+    cmp_ok( $got, '==', $expected, 'this == that' );
+
+    # ok( $got && $expected );
+    cmp_ok( $got, '&&', $expected, 'this && that' );
+    ...etc...
+
+Its advantage over C<ok()> is when the test fails you'll know what $got
+and $expected were:
+
+    not ok 1
+    #   Failed test in foo.t at line 12.
+    #     '23'
+    #         &&
+    #     undef
+
+It's also useful in those cases where you are comparing numbers and
+C<is()>'s use of C<eq> will interfere:
+
+    cmp_ok( $big_hairy_number, '==', $another_big_hairy_number );
+
+It's especially useful when comparing greater-than or smaller-than 
+relation between values:
+
+    cmp_ok( $some_value, '<=', $upper_limit );
+
+
+=cut
+
+sub cmp_ok($$$;$) {
+    my $tb = Test::More->builder;
+
+    return $tb->cmp_ok(@_);
+}
+
+=item B<can_ok>
+
+  can_ok($module, @methods);
+  can_ok($object, @methods);
+
+Checks to make sure the $module or $object can do these @methods
+(works with functions, too).
+
+    can_ok('Foo', qw(this that whatever));
+
+is almost exactly like saying:
+
+    ok( Foo->can('this') && 
+        Foo->can('that') && 
+        Foo->can('whatever') 
+      );
+
+only without all the typing and with a better interface.  Handy for
+quickly testing an interface.
+
+No matter how many @methods you check, a single C<can_ok()> call counts
+as one test.  If you desire otherwise, use:
+
+    foreach my $meth (@methods) {
+        can_ok('Foo', $meth);
+    }
+
+=cut
+
+sub can_ok ($@) {
+    my( $proto, @methods ) = @_;
+    my $class = ref $proto || $proto;
+    my $tb = Test::More->builder;
+
+    unless($class) {
+        my $ok = $tb->ok( 0, "->can(...)" );
+        $tb->diag('    can_ok() called with empty class or reference');
+        return $ok;
+    }
+
+    unless(@methods) {
+        my $ok = $tb->ok( 0, "$class->can(...)" );
+        $tb->diag('    can_ok() called with no methods');
+        return $ok;
+    }
+
+    my @nok;
+    foreach my $method (@methods) {
+        $tb->_try( sub { $proto->can($method) } ) or push @nok, $method;
+    }
+
+    my $name = (@methods == 1) ? "$class->can('$methods[0]')" :
+                                 "$class->can(...)"           ;
+
+    my $ok = $tb->ok( !@nok, $name );
+
+    $tb->diag( map "    $class->can('$_') failed\n", @nok );
+
+    return $ok;
+}
+
+=item B<isa_ok>
+
+  isa_ok($object,   $class, $object_name);
+  isa_ok($subclass, $class, $object_name);
+  isa_ok($ref,      $type,  $ref_name);
+
+Checks to see if the given C<< $object->isa($class) >>.  Also checks to make
+sure the object was defined in the first place.  Handy for this sort
+of thing:
+
+    my $obj = Some::Module->new;
+    isa_ok( $obj, 'Some::Module' );
+
+where you'd otherwise have to write
+
+    my $obj = Some::Module->new;
+    ok( defined $obj && $obj->isa('Some::Module') );
+
+to safeguard against your test script blowing up.
+
+You can also test a class, to make sure that it has the right ancestor:
+
+    isa_ok( 'Vole', 'Rodent' );
+
+It works on references, too:
+
+    isa_ok( $array_ref, 'ARRAY' );
+
+The diagnostics of this test normally just refer to 'the object'.  If
+you'd like them to be more specific, you can supply an $object_name
+(for example 'Test customer').
+
+=cut
+
+sub isa_ok ($$;$) {
+    my( $thing, $class, $thing_name ) = @_;
+    my $tb = Test::More->builder;
+
+    my $whatami;
+    if( !defined $thing ) {
+        $whatami = 'undef';
+    }
+    elsif( ref $thing ) {
+        $whatami = 'reference';
+
+        local($@,$!);
+        require Scalar::Util;
+        if( Scalar::Util::blessed($thing) ) {
+            $whatami = 'object';
+        }
+    }
+    else {
+        $whatami = 'class';
+    }
+
+    # We can't use UNIVERSAL::isa because we want to honor isa() overrides
+    my( $rslt, $error ) = $tb->_try( sub { $thing->isa($class) } );
+
+    if($error) {
+        die <<WHOA unless $error =~ /^Can't (locate|call) method "isa"/;
+WHOA! I tried to call ->isa on your $whatami and got some weird error.
+Here's the error.
+$error
+WHOA
+    }
+
+    # Special case for isa_ok( [], "ARRAY" ) and like
+    if( $whatami eq 'reference' ) {
+        $rslt = UNIVERSAL::isa($thing, $class);
+    }
+
+    my($diag, $name);
+    if( defined $thing_name ) {
+        $name = "'$thing_name' isa '$class'";
+        $diag = defined $thing ? "'$thing_name' isn't a '$class'" : "'$thing_name' isn't defined";
+    }
+    elsif( $whatami eq 'object' ) {
+        my $my_class = ref $thing;
+        $thing_name = qq[An object of class '$my_class'];
+        $name = "$thing_name isa '$class'";
+        $diag = "The object of class '$my_class' isn't a '$class'";
+    }
+    elsif( $whatami eq 'reference' ) {
+        my $type = ref $thing;
+        $thing_name = qq[A reference of type '$type'];
+        $name = "$thing_name isa '$class'";
+        $diag = "The reference of type '$type' isn't a '$class'";
+    }
+    elsif( $whatami eq 'undef' ) {
+        $thing_name = 'undef';
+        $name = "$thing_name isa '$class'";
+        $diag = "$thing_name isn't defined";
+    }
+    elsif( $whatami eq 'class' ) {
+        $thing_name = qq[The class (or class-like) '$thing'];
+        $name = "$thing_name isa '$class'";
+        $diag = "$thing_name isn't a '$class'";
+    }
+    else {
+        die;
+    }
+
+    my $ok;
+    if($rslt) {
+        $ok = $tb->ok( 1, $name );
+    }
+    else {
+        $ok = $tb->ok( 0, $name );
+        $tb->diag("    $diag\n");
+    }
+
+    return $ok;
+}
+
+=item B<new_ok>
+
+  my $obj = new_ok( $class );
+  my $obj = new_ok( $class => \@args );
+  my $obj = new_ok( $class => \@args, $object_name );
+
+A convenience function which combines creating an object and calling
+C<isa_ok()> on that object.
+
+It is basically equivalent to:
+
+    my $obj = $class->new(@args);
+    isa_ok $obj, $class, $object_name;
+
+If @args is not given, an empty list will be used.
+
+This function only works on C<new()> and it assumes C<new()> will return
+just a single object which isa C<$class>.
+
+=cut
+
+sub new_ok {
+    my $tb = Test::More->builder;
+    $tb->croak("new_ok() must be given at least a class") unless @_;
+
+    my( $class, $args, $object_name ) = @_;
+
+    $args ||= [];
+
+    my $obj;
+    my( $success, $error ) = $tb->_try( sub { $obj = $class->new(@$args); 1 } );
+    if($success) {
+        local $Test::Builder::Level = $Test::Builder::Level + 1;
+        isa_ok $obj, $class, $object_name;
+    }
+    else {
+        $class = 'undef' if !defined $class;
+        $tb->ok( 0, "$class->new() died" );
+        $tb->diag("    Error was:  $error");
+    }
+
+    return $obj;
+}
+
+=item B<subtest>
+
+    subtest $name => \&code, @args;
+
+C<subtest()> runs the &code as its own little test with its own plan and
+its own result.  The main test counts this as a single test using the
+result of the whole subtest to determine if its ok or not ok.
+
+For example...
+
+  use Test::More tests => 3;
+ 
+  pass("First test");
+
+  subtest 'An example subtest' => sub {
+      plan tests => 2;
+
+      pass("This is a subtest");
+      pass("So is this");
+  };
+
+  pass("Third test");
+
+This would produce.
+
+  1..3
+  ok 1 - First test
+      # Subtest: An example subtest
+      1..2
+      ok 1 - This is a subtest
+      ok 2 - So is this
+  ok 2 - An example subtest
+  ok 3 - Third test
+
+A subtest may call C<skip_all>.  No tests will be run, but the subtest is
+considered a skip.
+
+  subtest 'skippy' => sub {
+      plan skip_all => 'cuz I said so';
+      pass('this test will never be run');
+  };
+
+Returns true if the subtest passed, false otherwise.
+
+Due to how subtests work, you may omit a plan if you desire.  This adds an
+implicit C<done_testing()> to the end of your subtest.  The following two
+subtests are equivalent:
+
+  subtest 'subtest with implicit done_testing()', sub {
+      ok 1, 'subtests with an implicit done testing should work';
+      ok 1, '... and support more than one test';
+      ok 1, '... no matter how many tests are run';
+  };
+
+  subtest 'subtest with explicit done_testing()', sub {
+      ok 1, 'subtests with an explicit done testing should work';
+      ok 1, '... and support more than one test';
+      ok 1, '... no matter how many tests are run';
+      done_testing();
+  };
+
+Extra arguments given to C<subtest> are passed to the callback. For example:
+
+    sub my_subtest {
+        my $range = shift;
+        ...
+    }
+
+    for my $range (1, 10, 100, 1000) {
+        subtest "testing range $range", \&my_subtest, $range;
+    }
+
+=cut
+
+sub subtest {
+    my $tb = Test::More->builder;
+    return $tb->subtest(@_);
+}
+
+=item B<pass>
+
+=item B<fail>
+
+  pass($test_name);
+  fail($test_name);
+
+Sometimes you just want to say that the tests have passed.  Usually
+the case is you've got some complicated condition that is difficult to
+wedge into an C<ok()>.  In this case, you can simply use C<pass()> (to
+declare the test ok) or fail (for not ok).  They are synonyms for
+C<ok(1)> and C<ok(0)>.
+
+Use these very, very, very sparingly.
+
+=cut
+
+sub pass (;$) {
+    my $tb = Test::More->builder;
+
+    return $tb->ok( 1, @_ );
+}
+
+sub fail (;$) {
+    my $tb = Test::More->builder;
+
+    return $tb->ok( 0, @_ );
+}
+
+=back
+
+
+=head2 Module tests
+
+Sometimes you want to test if a module, or a list of modules, can
+successfully load.  For example, you'll often want a first test which
+simply loads all the modules in the distribution to make sure they
+work before going on to do more complicated testing.
+
+For such purposes we have C<use_ok> and C<require_ok>.
+
+=over 4
+
+=item B<require_ok>
+
+   require_ok($module);
+   require_ok($file);
+
+Tries to C<require> the given $module or $file.  If it loads
+successfully, the test will pass.  Otherwise it fails and displays the
+load error.
+
+C<require_ok> will guess whether the input is a module name or a
+filename.
+
+No exception will be thrown if the load fails.
+
+    # require Some::Module
+    require_ok "Some::Module";
+
+    # require "Some/File.pl";
+    require_ok "Some/File.pl";
+
+    # stop testing if any of your modules will not load
+    for my $module (@module) {
+        require_ok $module or BAIL_OUT "Can't load $module";
+    }
+
+=cut
+
+sub require_ok ($) {
+    my($module) = shift;
+    my $tb = Test::More->builder;
+
+    my $pack = caller;
+
+    # Try to determine if we've been given a module name or file.
+    # Module names must be barewords, files not.
+    $module = qq['$module'] unless _is_module_name($module);
+
+    my $code = <<REQUIRE;
+package $pack;
+require $module;
+1;
+REQUIRE
+
+    my( $eval_result, $eval_error ) = _eval($code);
+    my $ok = $tb->ok( $eval_result, "require $module;" );
+
+    unless($ok) {
+        chomp $eval_error;
+        $tb->diag(<<DIAGNOSTIC);
+    Tried to require '$module'.
+    Error:  $eval_error
+DIAGNOSTIC
+
+    }
+
+    return $ok;
+}
+
+sub _is_module_name {
+    my $module = shift;
+
+    # Module names start with a letter.
+    # End with an alphanumeric.
+    # The rest is an alphanumeric or ::
+    $module =~ s/\b::\b//g;
+
+    return $module =~ /^[a-zA-Z]\w*$/ ? 1 : 0;
+}
+
+
+=item B<use_ok>
+
+   BEGIN { use_ok($module); }
+   BEGIN { use_ok($module, @imports); }
+
+Like C<require_ok>, but it will C<use> the $module in question and
+only loads modules, not files.
+
+If you just want to test a module can be loaded, use C<require_ok>.
+
+If you just want to load a module in a test, we recommend simply using
+C<use> directly.  It will cause the test to stop.
+
+It's recommended that you run C<use_ok()> inside a BEGIN block so its
+functions are exported at compile-time and prototypes are properly
+honored.
+
+If @imports are given, they are passed through to the use.  So this:
+
+   BEGIN { use_ok('Some::Module', qw(foo bar)) }
+
+is like doing this:
+
+   use Some::Module qw(foo bar);
+
+Version numbers can be checked like so:
+
+   # Just like "use Some::Module 1.02"
+   BEGIN { use_ok('Some::Module', 1.02) }
+
+Don't try to do this:
+
+   BEGIN {
+       use_ok('Some::Module');
+
+       ...some code that depends on the use...
+       ...happening at compile time...
+   }
+
+because the notion of "compile-time" is relative.  Instead, you want:
+
+  BEGIN { use_ok('Some::Module') }
+  BEGIN { ...some code that depends on the use... }
+
+If you want the equivalent of C<use Foo ()>, use a module but not
+import anything, use C<require_ok>.
+
+  BEGIN { require_ok "Foo" }
+
+=cut
+
+sub use_ok ($;@) {
+    my( $module, @imports ) = @_;
+
+    my $tb = Test::More->builder;
+
+    my %caller;
+    @caller{qw/pack file line sub args want eval req strict warn/} = caller(0);
+
+    my ($pack, $filename, $line, $warn) = @caller{qw/pack file line warn/};
+    $filename =~ y/\n\r/_/; # so it doesn't run off the "#line $line $f" line
+
+    my $code;
+    if( @imports == 1 and $imports[0] =~ /^\d+(?:\.\d+)?$/ ) {
+        # probably a version check.  Perl needs to see the bare number
+        # for it to work with non-Exporter based modules.
+        $code = <<USE;
+package $pack;
+BEGIN { \${^WARNING_BITS} = \$args[-1] if defined \$args[-1] }
+#line $line $filename
+use $module $imports[0];
+1;
+USE
+    }
+    else {
+        $code = <<USE;
+package $pack;
+BEGIN { \${^WARNING_BITS} = \$args[-1] if defined \$args[-1] }
+#line $line $filename
+use $module \@{\$args[0]};
+1;
+USE
+    }
+
+    my ($eval_result, $eval_error) = _eval($code, \@imports, $warn);
+    my $ok = $tb->ok( $eval_result, "use $module;" );
+
+    unless($ok) {
+        chomp $eval_error;
+        $@ =~ s{^BEGIN failed--compilation aborted at .*$}
+                {BEGIN failed--compilation aborted at $filename line $line.}m;
+        $tb->diag(<<DIAGNOSTIC);
+    Tried to use '$module'.
+    Error:  $eval_error
+DIAGNOSTIC
+
+    }
+
+    return $ok;
+}
+
+sub _eval {
+    my( $code, @args ) = @_;
+
+    # Work around oddities surrounding resetting of $@ by immediately
+    # storing it.
+    my( $sigdie, $eval_result, $eval_error );
+    {
+        local( $@, $!, $SIG{__DIE__} );    # isolate eval
+        $eval_result = eval $code;              ## no critic (BuiltinFunctions::ProhibitStringyEval)
+        $eval_error  = $@;
+        $sigdie      = $SIG{__DIE__} || undef;
+    }
+    # make sure that $code got a chance to set $SIG{__DIE__}
+    $SIG{__DIE__} = $sigdie if defined $sigdie;
+
+    return( $eval_result, $eval_error );
+}
+
+
+=back
+
+
+=head2 Complex data structures
+
+Not everything is a simple eq check or regex.  There are times you
+need to see if two data structures are equivalent.  For these
+instances Test::More provides a handful of useful functions.
+
+B<NOTE> I'm not quite sure what will happen with filehandles.
+
+=over 4
+
+=item B<is_deeply>
+
+  is_deeply( $got, $expected, $test_name );
+
+Similar to C<is()>, except that if $got and $expected are references, it
+does a deep comparison walking each data structure to see if they are
+equivalent.  If the two structures are different, it will display the
+place where they start differing.
+
+C<is_deeply()> compares the dereferenced values of references, the
+references themselves (except for their type) are ignored.  This means
+aspects such as blessing and ties are not considered "different".
+
+C<is_deeply()> currently has very limited handling of function reference
+and globs.  It merely checks if they have the same referent.  This may
+improve in the future.
+
+L<Test::Differences> and L<Test::Deep> provide more in-depth functionality
+along these lines.
+
+B<NOTE> is_deeply() has limitations when it comes to comparing strings and
+refs:
+
+    my $path = path('.');
+    my $hash = {};
+    is_deeply( $path, "$path" ); # ok
+    is_deeply( $hash, "$hash" ); # fail
+
+This happens because is_deeply will unoverload all arguments unconditionally.
+It is probably best not to use is_deeply with overloading. For legacy reasons
+this is not likely to ever be fixed. If you would like a much better tool for
+this you should see L<Test2::Suite> Specifically L<Test2::Tools::Compare> has
+an C<is()> function that works like C<is_deeply> with many improvements.
+
+=cut
+
+our( @Data_Stack, %Refs_Seen );
+my $DNE = bless [], 'Does::Not::Exist';
+
+sub _dne {
+    return ref $_[0] eq ref $DNE;
+}
+
+## no critic (Subroutines::RequireArgUnpacking)
+sub is_deeply {
+    my $tb = Test::More->builder;
+
+    unless( @_ == 2 or @_ == 3 ) {
+        my $msg = <<'WARNING';
+is_deeply() takes two or three args, you gave %d.
+This usually means you passed an array or hash instead 
+of a reference to it
+WARNING
+        chop $msg;    # clip off newline so carp() will put in line/file
+
+        _carp sprintf $msg, scalar @_;
+
+        return $tb->ok(0);
+    }
+
+    my( $got, $expected, $name ) = @_;
+
+    $tb->_unoverload_str( \$expected, \$got );
+
+    my $ok;
+    if( !ref $got and !ref $expected ) {    # neither is a reference
+        $ok = $tb->is_eq( $got, $expected, $name );
+    }
+    elsif( !ref $got xor !ref $expected ) {    # one's a reference, one isn't
+        $ok = $tb->ok( 0, $name );
+        $tb->diag( _format_stack({ vals => [ $got, $expected ] }) );
+    }
+    else {                                     # both references
+        local @Data_Stack = ();
+        if( _deep_check( $got, $expected ) ) {
+            $ok = $tb->ok( 1, $name );
+        }
+        else {
+            $ok = $tb->ok( 0, $name );
+            $tb->diag( _format_stack(@Data_Stack) );
+        }
+    }
+
+    return $ok;
+}
+
+sub _format_stack {
+    my(@Stack) = @_;
+
+    my $var       = '$FOO';
+    my $did_arrow = 0;
+    foreach my $entry (@Stack) {
+        my $type = $entry->{type} || '';
+        my $idx = $entry->{'idx'};
+        if( $type eq 'HASH' ) {
+            $var .= "->" unless $did_arrow++;
+            $var .= "{$idx}";
+        }
+        elsif( $type eq 'ARRAY' ) {
+            $var .= "->" unless $did_arrow++;
+            $var .= "[$idx]";
+        }
+        elsif( $type eq 'REF' ) {
+            $var = "\${$var}";
+        }
+    }
+
+    my @vals = @{ $Stack[-1]{vals} }[ 0, 1 ];
+    my @vars;
+    ( $vars[0] = $var ) =~ s/\$FOO/     \$got/;
+    ( $vars[1] = $var ) =~ s/\$FOO/\$expected/;
+
+    my $out = "Structures begin differing at:\n";
+    foreach my $idx ( 0 .. $#vals ) {
+        my $val = $vals[$idx];
+        $vals[$idx]
+          = !defined $val ? 'undef'
+          : _dne($val)    ? "Does not exist"
+          : ref $val      ? "$val"
+          :                 "'$val'";
+    }
+
+    $out .= "$vars[0] = $vals[0]\n";
+    $out .= "$vars[1] = $vals[1]\n";
+
+    $out =~ s/^/    /msg;
+    return $out;
+}
+
+my %_types = (
+  (map +($_ => $_), qw(
+    Regexp
+    ARRAY
+    HASH
+    SCALAR
+    REF
+    GLOB
+    CODE
+  )),
+  'LVALUE'  => 'SCALAR',
+  'REF'     => 'SCALAR',
+  'VSTRING' => 'SCALAR',
+);
+
+sub _type {
+    my $thing = shift;
+
+    return '' if !ref $thing;
+
+    for my $type (keys %_types) {
+        return $_types{$type} if UNIVERSAL::isa( $thing, $type );
+    }
+
+    return '';
+}
+
+=back
+
+
+=head2 Diagnostics
+
+If you pick the right test function, you'll usually get a good idea of
+what went wrong when it failed.  But sometimes it doesn't work out
+that way.  So here we have ways for you to write your own diagnostic
+messages which are safer than just C<print STDERR>.
+
+=over 4
+
+=item B<diag>
+
+  diag(@diagnostic_message);
+
+Prints a diagnostic message which is guaranteed not to interfere with
+test output.  Like C<print> @diagnostic_message is simply concatenated
+together.
+
+Returns false, so as to preserve failure.
+
+Handy for this sort of thing:
+
+    ok( grep(/foo/, @users), "There's a foo user" ) or
+        diag("Since there's no foo, check that /etc/bar is set up right");
+
+which would produce:
+
+    not ok 42 - There's a foo user
+    #   Failed test 'There's a foo user'
+    #   in foo.t at line 52.
+    # Since there's no foo, check that /etc/bar is set up right.
+
+You might remember C<ok() or diag()> with the mnemonic C<open() or
+die()>.
+
+B<NOTE> The exact formatting of the diagnostic output is still
+changing, but it is guaranteed that whatever you throw at it won't
+interfere with the test.
+
+=item B<note>
+
+  note(@diagnostic_message);
+
+Like C<diag()>, except the message will not be seen when the test is run
+in a harness.  It will only be visible in the verbose TAP stream.
+
+Handy for putting in notes which might be useful for debugging, but
+don't indicate a problem.
+
+    note("Tempfile is $tempfile");
+
+=cut
+
+sub diag {
+    return Test::More->builder->diag(@_);
+}
+
+sub note {
+    return Test::More->builder->note(@_);
+}
+
+=item B<explain>
+
+  my @dump = explain @diagnostic_message;
+
+Will dump the contents of any references in a human readable format.
+Usually you want to pass this into C<note> or C<diag>.
+
+Handy for things like...
+
+    is_deeply($have, $want) || diag explain $have;
+
+or
+
+    note explain \%args;
+    Some::Class->method(%args);
+
+=cut
+
+sub explain {
+    return Test::More->builder->explain(@_);
+}
+
+=back
+
+
+=head2 Conditional tests
+
+Sometimes running a test under certain conditions will cause the
+test script to die.  A certain function or method isn't implemented
+(such as C<fork()> on MacOS), some resource isn't available (like a 
+net connection) or a module isn't available.  In these cases it's
+necessary to skip tests, or declare that they are supposed to fail
+but will work in the future (a todo test).
+
+For more details on the mechanics of skip and todo tests see
+L<Test::Harness>.
+
+The way Test::More handles this is with a named block.  Basically, a
+block of tests which can be skipped over or made todo.  It's best if I
+just show you...
+
+=over 4
+
+=item B<SKIP: BLOCK>
+
+  SKIP: {
+      skip $why, $how_many if $condition;
+
+      ...normal testing code goes here...
+  }
+
+This declares a block of tests that might be skipped, $how_many tests
+there are, $why and under what $condition to skip them.  An example is
+the easiest way to illustrate:
+
+    SKIP: {
+        eval { require HTML::Lint };
+
+        skip "HTML::Lint not installed", 2 if $@;
+
+        my $lint = new HTML::Lint;
+        isa_ok( $lint, "HTML::Lint" );
+
+        $lint->parse( $html );
+        is( $lint->errors, 0, "No errors found in HTML" );
+    }
+
+If the user does not have HTML::Lint installed, the whole block of
+code I<won't be run at all>.  Test::More will output special ok's
+which Test::Harness interprets as skipped, but passing, tests.
+
+It's important that $how_many accurately reflects the number of tests
+in the SKIP block so the # of tests run will match up with your plan.
+If your plan is C<no_plan> $how_many is optional and will default to 1.
+
+It's perfectly safe to nest SKIP blocks.  Each SKIP block must have
+the label C<SKIP>, or Test::More can't work its magic.
+
+You don't skip tests which are failing because there's a bug in your
+program, or for which you don't yet have code written.  For that you
+use TODO.  Read on.
+
+=cut
+
+## no critic (Subroutines::RequireFinalReturn)
+sub skip {
+    my( $why, $how_many ) = @_;
+    my $tb = Test::More->builder;
+
+    # If the plan is set, and is static, then skip needs a count. If the plan
+    # is 'no_plan' we are fine. As well if plan is undefined then we are
+    # waiting for done_testing.
+    unless (defined $how_many) {
+        my $plan = $tb->has_plan;
+        _carp "skip() needs to know \$how_many tests are in the block"
+            if $plan && $plan =~ m/^\d+$/;
+        $how_many = 1;
+    }
+
+    if( defined $how_many and $how_many =~ /\D/ ) {
+        _carp
+          "skip() was passed a non-numeric number of tests.  Did you get the arguments backwards?";
+        $how_many = 1;
+    }
+
+    for( 1 .. $how_many ) {
+        $tb->skip($why);
+    }
+
+    no warnings 'exiting';
+    last SKIP;
+}
+
+=item B<TODO: BLOCK>
+
+    TODO: {
+        local $TODO = $why if $condition;
+
+        ...normal testing code goes here...
+    }
+
+Declares a block of tests you expect to fail and $why.  Perhaps it's
+because you haven't fixed a bug or haven't finished a new feature:
+
+    TODO: {
+        local $TODO = "URI::Geller not finished";
+
+        my $card = "Eight of clubs";
+        is( URI::Geller->your_card, $card, 'Is THIS your card?' );
+
+        my $spoon;
+        URI::Geller->bend_spoon;
+        is( $spoon, 'bent',    "Spoon bending, that's original" );
+    }
+
+With a todo block, the tests inside are expected to fail.  Test::More
+will run the tests normally, but print out special flags indicating
+they are "todo".  L<Test::Harness> will interpret failures as being ok.
+Should anything succeed, it will report it as an unexpected success.
+You then know the thing you had todo is done and can remove the
+TODO flag.
+
+The nice part about todo tests, as opposed to simply commenting out a
+block of tests, is that it is like having a programmatic todo list.  You know
+how much work is left to be done, you're aware of what bugs there are,
+and you'll know immediately when they're fixed.
+
+Once a todo test starts succeeding, simply move it outside the block.
+When the block is empty, delete it.
+
+Note that, if you leave $TODO unset or undef, Test::More reports failures
+as normal. This can be useful to mark the tests as expected to fail only
+in certain conditions, e.g.:
+
+    TODO: {
+        local $TODO = "$^O doesn't work yet. :(" if !_os_is_supported($^O);
+
+        ...
+    }
+
+=item B<todo_skip>
+
+    TODO: {
+        todo_skip $why, $how_many if $condition;
+
+        ...normal testing code...
+    }
+
+With todo tests, it's best to have the tests actually run.  That way
+you'll know when they start passing.  Sometimes this isn't possible.
+Often a failing test will cause the whole program to die or hang, even
+inside an C<eval BLOCK> with and using C<alarm>.  In these extreme
+cases you have no choice but to skip over the broken tests entirely.
+
+The syntax and behavior is similar to a C<SKIP: BLOCK> except the
+tests will be marked as failing but todo.  L<Test::Harness> will
+interpret them as passing.
+
+=cut
+
+sub todo_skip {
+    my( $why, $how_many ) = @_;
+    my $tb = Test::More->builder;
+
+    unless( defined $how_many ) {
+        # $how_many can only be avoided when no_plan is in use.
+        _carp "todo_skip() needs to know \$how_many tests are in the block"
+          unless $tb->has_plan eq 'no_plan';
+        $how_many = 1;
+    }
+
+    for( 1 .. $how_many ) {
+        $tb->todo_skip($why);
+    }
+
+    no warnings 'exiting';
+    last TODO;
+}
+
+=item When do I use SKIP vs. TODO?
+
+B<If it's something the user might not be able to do>, use SKIP.
+This includes optional modules that aren't installed, running under
+an OS that doesn't have some feature (like C<fork()> or symlinks), or maybe
+you need an Internet connection and one isn't available.
+
+B<If it's something the programmer hasn't done yet>, use TODO.  This
+is for any code you haven't written yet, or bugs you have yet to fix,
+but want to put tests in your testing script (always a good idea).
+
+
+=back
+
+
+=head2 Test control
+
+=over 4
+
+=item B<BAIL_OUT>
+
+    BAIL_OUT($reason);
+
+Indicates to the harness that things are going so badly all testing
+should terminate.  This includes the running of any additional test scripts.
+
+This is typically used when testing cannot continue such as a critical
+module failing to compile or a necessary external utility not being
+available such as a database connection failing.
+
+The test will exit with 255.
+
+For even better control look at L<Test::Most>.
+
+=cut
+
+sub BAIL_OUT {
+    my $reason = shift;
+    my $tb     = Test::More->builder;
+
+    $tb->BAIL_OUT($reason);
+}
+
+=back
+
+
+=head2 Discouraged comparison functions
+
+The use of the following functions is discouraged as they are not
+actually testing functions and produce no diagnostics to help figure
+out what went wrong.  They were written before C<is_deeply()> existed
+because I couldn't figure out how to display a useful diff of two
+arbitrary data structures.
+
+These functions are usually used inside an C<ok()>.
+
+    ok( eq_array(\@got, \@expected) );
+
+C<is_deeply()> can do that better and with diagnostics.  
+
+    is_deeply( \@got, \@expected );
+
+They may be deprecated in future versions.
+
+=over 4
+
+=item B<eq_array>
+
+  my $is_eq = eq_array(\@got, \@expected);
+
+Checks if two arrays are equivalent.  This is a deep check, so
+multi-level structures are handled correctly.
+
+=cut
+
+#'#
+sub eq_array {
+    local @Data_Stack = ();
+    _deep_check(@_);
+}
+
+sub _eq_array {
+    my( $a1, $a2 ) = @_;
+
+    if( grep _type($_) ne 'ARRAY', $a1, $a2 ) {
+        warn "eq_array passed a non-array ref";
+        return 0;
+    }
+
+    return 1 if $a1 eq $a2;
+
+    my $ok = 1;
+    my $max = $#$a1 > $#$a2 ? $#$a1 : $#$a2;
+    for( 0 .. $max ) {
+        my $e1 = $_ > $#$a1 ? $DNE : $a1->[$_];
+        my $e2 = $_ > $#$a2 ? $DNE : $a2->[$_];
+
+        next if _equal_nonrefs($e1, $e2);
+
+        push @Data_Stack, { type => 'ARRAY', idx => $_, vals => [ $e1, $e2 ] };
+        $ok = _deep_check( $e1, $e2 );
+        pop @Data_Stack if $ok;
+
+        last unless $ok;
+    }
+
+    return $ok;
+}
+
+sub _equal_nonrefs {
+    my( $e1, $e2 ) = @_;
+
+    return if ref $e1 or ref $e2;
+
+    if ( defined $e1 ) {
+        return 1 if defined $e2 and $e1 eq $e2;
+    }
+    else {
+        return 1 if !defined $e2;
+    }
+
+    return;
+}
+
+sub _deep_check {
+    my( $e1, $e2 ) = @_;
+    my $tb = Test::More->builder;
+
+    my $ok = 0;
+
+    # Effectively turn %Refs_Seen into a stack.  This avoids picking up
+    # the same referenced used twice (such as [\$a, \$a]) to be considered
+    # circular.
+    local %Refs_Seen = %Refs_Seen;
+
+    {
+        $tb->_unoverload_str( \$e1, \$e2 );
+
+        # Either they're both references or both not.
+        my $same_ref = !( !ref $e1 xor !ref $e2 );
+        my $not_ref = ( !ref $e1 and !ref $e2 );
+
+        if( defined $e1 xor defined $e2 ) {
+            $ok = 0;
+        }
+        elsif( !defined $e1 and !defined $e2 ) {
+            # Shortcut if they're both undefined.
+            $ok = 1;
+        }
+        elsif( _dne($e1) xor _dne($e2) ) {
+            $ok = 0;
+        }
+        elsif( $same_ref and( $e1 eq $e2 ) ) {
+            $ok = 1;
+        }
+        elsif($not_ref) {
+            push @Data_Stack, { type => '', vals => [ $e1, $e2 ] };
+            $ok = 0;
+        }
+        else {
+            if( $Refs_Seen{$e1} ) {
+                return $Refs_Seen{$e1} eq $e2;
+            }
+            else {
+                $Refs_Seen{$e1} = "$e2";
+            }
+
+            my $type = _type($e1);
+            $type = 'DIFFERENT' unless _type($e2) eq $type;
+
+            if( $type eq 'DIFFERENT' ) {
+                push @Data_Stack, { type => $type, vals => [ $e1, $e2 ] };
+                $ok = 0;
+            }
+            elsif( $type eq 'ARRAY' ) {
+                $ok = _eq_array( $e1, $e2 );
+            }
+            elsif( $type eq 'HASH' ) {
+                $ok = _eq_hash( $e1, $e2 );
+            }
+            elsif( $type eq 'REF' ) {
+                push @Data_Stack, { type => $type, vals => [ $e1, $e2 ] };
+                $ok = _deep_check( $$e1, $$e2 );
+                pop @Data_Stack if $ok;
+            }
+            elsif( $type eq 'SCALAR' ) {
+                push @Data_Stack, { type => 'REF', vals => [ $e1, $e2 ] };
+                $ok = _deep_check( $$e1, $$e2 );
+                pop @Data_Stack if $ok;
+            }
+            elsif($type) {
+                push @Data_Stack, { type => $type, vals => [ $e1, $e2 ] };
+                $ok = 0;
+            }
+            else {
+                _whoa( 1, "No type in _deep_check" );
+            }
+        }
+    }
+
+    return $ok;
+}
+
+sub _whoa {
+    my( $check, $desc ) = @_;
+    if($check) {
+        die <<"WHOA";
+WHOA!  $desc
+This should never happen!  Please contact the author immediately!
+WHOA
+    }
+}
+
+=item B<eq_hash>
+
+  my $is_eq = eq_hash(\%got, \%expected);
+
+Determines if the two hashes contain the same keys and values.  This
+is a deep check.
+
+=cut
+
+sub eq_hash {
+    local @Data_Stack = ();
+    return _deep_check(@_);
+}
+
+sub _eq_hash {
+    my( $a1, $a2 ) = @_;
+
+    if( grep _type($_) ne 'HASH', $a1, $a2 ) {
+        warn "eq_hash passed a non-hash ref";
+        return 0;
+    }
+
+    return 1 if $a1 eq $a2;
+
+    my $ok = 1;
+    my $bigger = keys %$a1 > keys %$a2 ? $a1 : $a2;
+    foreach my $k ( keys %$bigger ) {
+        my $e1 = exists $a1->{$k} ? $a1->{$k} : $DNE;
+        my $e2 = exists $a2->{$k} ? $a2->{$k} : $DNE;
+
+        next if _equal_nonrefs($e1, $e2);
+
+        push @Data_Stack, { type => 'HASH', idx => $k, vals => [ $e1, $e2 ] };
+        $ok = _deep_check( $e1, $e2 );
+        pop @Data_Stack if $ok;
+
+        last unless $ok;
+    }
+
+    return $ok;
+}
+
+=item B<eq_set>
+
+  my $is_eq = eq_set(\@got, \@expected);
+
+Similar to C<eq_array()>, except the order of the elements is B<not>
+important.  This is a deep check, but the irrelevancy of order only
+applies to the top level.
+
+    ok( eq_set(\@got, \@expected) );
+
+Is better written:
+
+    is_deeply( [sort @got], [sort @expected] );
+
+B<NOTE> By historical accident, this is not a true set comparison.
+While the order of elements does not matter, duplicate elements do.
+
+B<NOTE> C<eq_set()> does not know how to deal with references at the top
+level.  The following is an example of a comparison which might not work:
+
+    eq_set([\1, \2], [\2, \1]);
+
+L<Test::Deep> contains much better set comparison functions.
+
+=cut
+
+sub eq_set {
+    my( $a1, $a2 ) = @_;
+    return 0 unless @$a1 == @$a2;
+
+    no warnings 'uninitialized';
+
+    # It really doesn't matter how we sort them, as long as both arrays are
+    # sorted with the same algorithm.
+    #
+    # Ensure that references are not accidentally treated the same as a
+    # string containing the reference.
+    #
+    # Have to inline the sort routine due to a threading/sort bug.
+    # See [rt.cpan.org 6782]
+    #
+    # I don't know how references would be sorted so we just don't sort
+    # them.  This means eq_set doesn't really work with refs.
+    return eq_array(
+        [ grep( ref, @$a1 ), sort( grep( !ref, @$a1 ) ) ],
+        [ grep( ref, @$a2 ), sort( grep( !ref, @$a2 ) ) ],
+    );
+}
+
+=back
+
+
+=head2 Extending and Embedding Test::More
+
+Sometimes the Test::More interface isn't quite enough.  Fortunately,
+Test::More is built on top of L<Test::Builder> which provides a single,
+unified backend for any test library to use.  This means two test
+libraries which both use L<Test::Builder> B<can> be used together in the
+same program.
+
+If you simply want to do a little tweaking of how the tests behave,
+you can access the underlying L<Test::Builder> object like so:
+
+=over 4
+
+=item B<builder>
+
+    my $test_builder = Test::More->builder;
+
+Returns the L<Test::Builder> object underlying Test::More for you to play
+with.
+
+
+=back
+
+
+=head1 EXIT CODES
+
+If all your tests passed, L<Test::Builder> will exit with zero (which is
+normal).  If anything failed it will exit with how many failed.  If
+you run less (or more) tests than you planned, the missing (or extras)
+will be considered failures.  If no tests were ever run L<Test::Builder>
+will throw a warning and exit with 255.  If the test died, even after
+having successfully completed all its tests, it will still be
+considered a failure and will exit with 255.
+
+So the exit codes are...
+
+    0                   all tests successful
+    255                 test died or all passed but wrong # of tests run
+    any other number    how many failed (including missing or extras)
+
+If you fail more than 254 tests, it will be reported as 254.
+
+B<NOTE>  This behavior may go away in future versions.
+
+
+=head1 COMPATIBILITY
+
+Test::More works with Perls as old as 5.8.1.
+
+Thread support is not very reliable before 5.10.1, but that's
+because threads are not very reliable before 5.10.1.
+
+Although Test::More has been a core module in versions of Perl since 5.6.2, Test::More has evolved since then, and not all of the features you're used to will be present in the shipped version of Test::More. If you are writing a module, don't forget to indicate in your package metadata the minimum version of Test::More that you require. For instance, if you want to use C<done_testing()> but want your test script to run on Perl 5.10.0, you will need to explicitly require Test::More > 0.88.
+
+Key feature milestones include:
+
+=over 4
+
+=item subtests
+
+Subtests were released in Test::More 0.94, which came with Perl 5.12.0. Subtests did not implicitly call C<done_testing()> until 0.96; the first Perl with that fix was Perl 5.14.0 with 0.98.
+
+=item C<done_testing()>
+
+This was released in Test::More 0.88 and first shipped with Perl in 5.10.1 as part of Test::More 0.92. 
+
+=item C<cmp_ok()>
+
+Although C<cmp_ok()> was introduced in 0.40, 0.86 fixed an important bug to make it safe for overloaded objects; the fixed first shipped with Perl in 5.10.1 as part of Test::More 0.92.
+
+=item C<new_ok()> C<note()> and C<explain()>
+
+These were was released in Test::More 0.82, and first shipped with Perl in 5.10.1 as part of Test::More 0.92. 
+
+=back
+
+There is a full version history in the Changes file, and the Test::More versions included as core can be found using L<Module::CoreList>:
+
+    $ corelist -a Test::More
+
+
+=head1 CAVEATS and NOTES
+
+=over 4
+
+=item UTF-8 / "Wide character in print"
+
+If you use UTF-8 or other non-ASCII characters with Test::More you
+might get a "Wide character in print" warning.  Using
+C<< binmode STDOUT, ":utf8" >> will not fix it.
+L<Test::Builder> (which powers
+Test::More) duplicates STDOUT and STDERR.  So any changes to them,
+including changing their output disciplines, will not be seen by
+Test::More.
+
+One work around is to apply encodings to STDOUT and STDERR as early
+as possible and before Test::More (or any other Test module) loads.
+
+    use open ':std', ':encoding(UTF-8)';
+    use Test::More;
+
+A more direct work around is to change the filehandles used by
+L<Test::Builder>.
+
+    my $builder = Test::More->builder;
+    binmode $builder->output,         ":encoding(UTF-8)";
+    binmode $builder->failure_output, ":encoding(UTF-8)";
+    binmode $builder->todo_output,    ":encoding(UTF-8)";
+
+
+=item Overloaded objects
+
+String overloaded objects are compared B<as strings> (or in C<cmp_ok()>'s
+case, strings or numbers as appropriate to the comparison op).  This
+prevents Test::More from piercing an object's interface allowing
+better blackbox testing.  So if a function starts returning overloaded
+objects instead of bare strings your tests won't notice the
+difference.  This is good.
+
+However, it does mean that functions like C<is_deeply()> cannot be used to
+test the internals of string overloaded objects.  In this case I would
+suggest L<Test::Deep> which contains more flexible testing functions for
+complex data structures.
+
+
+=item Threads
+
+Test::More will only be aware of threads if C<use threads> has been done
+I<before> Test::More is loaded.  This is ok:
+
+    use threads;
+    use Test::More;
+
+This may cause problems:
+
+    use Test::More
+    use threads;
+
+5.8.1 and above are supported.  Anything below that has too many bugs.
+
+=back
+
+
+=head1 HISTORY
+
+This is a case of convergent evolution with Joshua Pritikin's L<Test>
+module.  I was largely unaware of its existence when I'd first
+written my own C<ok()> routines.  This module exists because I can't
+figure out how to easily wedge test names into Test's interface (along
+with a few other problems).
+
+The goal here is to have a testing utility that's simple to learn,
+quick to use and difficult to trip yourself up with while still
+providing more flexibility than the existing Test.pm.  As such, the
+names of the most common routines are kept tiny, special cases and
+magic side-effects are kept to a minimum.  WYSIWYG.
+
+
+=head1 SEE ALSO
+
+=head2
+
+=head2 ALTERNATIVES
+
+L<Test2::Suite> is the most recent and modern set of tools for testing.
+
+L<Test::Simple> if all this confuses you and you just want to write
+some tests.  You can upgrade to Test::More later (it's forward
+compatible).
+
+L<Test::Legacy> tests written with Test.pm, the original testing
+module, do not play well with other testing libraries.  Test::Legacy
+emulates the Test.pm interface and does play well with others.
+
+=head2 ADDITIONAL LIBRARIES
+
+L<Test::Differences> for more ways to test complex data structures.
+And it plays well with Test::More.
+
+L<Test::Class> is like xUnit but more perlish.
+
+L<Test::Deep> gives you more powerful complex data structure testing.
+
+L<Test::Inline> shows the idea of embedded testing.
+
+L<Mock::Quick> The ultimate mocking library. Easily spawn objects defined on
+the fly. Can also override, block, or reimplement packages as needed.
+
+L<Test::FixtureBuilder> Quickly define fixture data for unit tests.
+
+=head2 OTHER COMPONENTS
+
+L<Test::Harness> is the test runner and output interpreter for Perl.
+It's the thing that powers C<make test> and where the C<prove> utility
+comes from.
+
+=head2 BUNDLES
+
+L<Test::Most> Most commonly needed test functions and features.
+
+=head1 ENVIRONMENT VARIABLES
+
+See L<Test2::Env> for a list of meaningul environment variables.
+
+=head1 AUTHORS
+
+Michael G Schwern E<lt>schwern@pobox.comE<gt> with much inspiration
+from Joshua Pritikin's Test module and lots of help from Barrie
+Slaymaker, Tony Bowden, blackstar.co.uk, chromatic, Fergal Daly and
+the perl-qa gang.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+
+=head1 BUGS
+
+See L<https://github.com/Test-More/test-more/issues> to report and view bugs.
+
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+L<https://github.com/Test-More/test-more/>.
+
+
+=head1 COPYRIGHT
+
+Copyright 2001-2008 by Michael G Schwern E<lt>schwern@pobox.comE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut
+
+1;

git/usr/share/perl5/core_perl/Test/Simple.pm

@@ -0,0 +1,220 @@
+package Test::Simple;
+
+use 5.006;
+
+use strict;
+
+our $VERSION = '1.302210';
+
+use Test::Builder::Module;
+our @ISA    = qw(Test::Builder::Module);
+our @EXPORT = qw(ok);
+
+my $CLASS = __PACKAGE__;
+
+=head1 NAME
+
+Test::Simple - Basic utilities for writing tests.
+
+=head1 SYNOPSIS
+
+  use Test::Simple tests => 1;
+
+  ok( $foo eq $bar, 'foo is bar' );
+
+
+=head1 DESCRIPTION
+
+** If you are unfamiliar with testing B<read L<Test::Tutorial> first!> **
+
+This is an extremely simple, extremely basic module for writing tests
+suitable for CPAN modules and other pursuits.  If you wish to do more
+complicated testing, use the Test::More module (a drop-in replacement
+for this one).
+
+The basic unit of Perl testing is the ok.  For each thing you want to
+test your program will print out an "ok" or "not ok" to indicate pass
+or fail.  You do this with the C<ok()> function (see below).
+
+The only other constraint is you must pre-declare how many tests you
+plan to run.  This is in case something goes horribly wrong during the
+test and your test program aborts, or skips a test or whatever.  You
+do this like so:
+
+    use Test::Simple tests => 23;
+
+You must have a plan.
+
+
+=over 4
+
+=item B<ok>
+
+  ok( $foo eq $bar, $name );
+  ok( $foo eq $bar );
+
+C<ok()> is given an expression (in this case C<$foo eq $bar>).  If it's
+true, the test passed.  If it's false, it didn't.  That's about it.
+
+C<ok()> prints out either "ok" or "not ok" along with a test number (it
+keeps track of that for you).
+
+  # This produces "ok 1 - Hell not yet frozen over" (or not ok)
+  ok( get_temperature($hell) > 0, 'Hell not yet frozen over' );
+
+If you provide a $name, that will be printed along with the "ok/not
+ok" to make it easier to find your test when if fails (just search for
+the name).  It also makes it easier for the next guy to understand
+what your test is for.  It's highly recommended you use test names.
+
+All tests are run in scalar context.  So this:
+
+    ok( @stuff, 'I have some stuff' );
+
+will do what you mean (fail if stuff is empty)
+
+=cut
+
+sub ok ($;$) {    ## no critic (Subroutines::ProhibitSubroutinePrototypes)
+    return $CLASS->builder->ok(@_);
+}
+
+=back
+
+Test::Simple will start by printing number of tests run in the form
+"1..M" (so "1..5" means you're going to run 5 tests).  This strange
+format lets L<Test::Harness> know how many tests you plan on running in
+case something goes horribly wrong.
+
+If all your tests passed, Test::Simple will exit with zero (which is
+normal).  If anything failed it will exit with how many failed.  If
+you run less (or more) tests than you planned, the missing (or extras)
+will be considered failures.  If no tests were ever run Test::Simple
+will throw a warning and exit with 255.  If the test died, even after
+having successfully completed all its tests, it will still be
+considered a failure and will exit with 255.
+
+So the exit codes are...
+
+    0                   all tests successful
+    255                 test died or all passed but wrong # of tests run
+    any other number    how many failed (including missing or extras)
+
+If you fail more than 254 tests, it will be reported as 254.
+
+This module is by no means trying to be a complete testing system.
+It's just to get you started.  Once you're off the ground its
+recommended you look at L<Test::More>.
+
+
+=head1 EXAMPLE
+
+Here's an example of a simple .t file for the fictional Film module.
+
+    use Test::Simple tests => 5;
+
+    use Film;  # What you're testing.
+
+    my $btaste = Film->new({ Title    => 'Bad Taste',
+                             Director => 'Peter Jackson',
+                             Rating   => 'R',
+                             NumExplodingSheep => 1
+                           });
+    ok( defined($btaste) && ref $btaste eq 'Film',     'new() works' );
+
+    ok( $btaste->Title      eq 'Bad Taste',     'Title() get'    );
+    ok( $btaste->Director   eq 'Peter Jackson', 'Director() get' );
+    ok( $btaste->Rating     eq 'R',             'Rating() get'   );
+    ok( $btaste->NumExplodingSheep == 1,        'NumExplodingSheep() get' );
+
+It will produce output like this:
+
+    1..5
+    ok 1 - new() works
+    ok 2 - Title() get
+    ok 3 - Director() get
+    not ok 4 - Rating() get
+    #   Failed test 'Rating() get'
+    #   in t/film.t at line 14.
+    ok 5 - NumExplodingSheep() get
+    # Looks like you failed 1 tests of 5
+
+Indicating the Film::Rating() method is broken.
+
+
+=head1 CAVEATS
+
+Test::Simple will only report a maximum of 254 failures in its exit
+code.  If this is a problem, you probably have a huge test script.
+Split it into multiple files.  (Otherwise blame the Unix folks for
+using an unsigned short integer as the exit status).
+
+Because VMS's exit codes are much, much different than the rest of the
+universe, and perl does horrible mangling to them that gets in my way,
+it works like this on VMS.
+
+    0     SS$_NORMAL        all tests successful
+    4     SS$_ABORT         something went wrong
+
+Unfortunately, I can't differentiate any further.
+
+
+=head1 NOTES
+
+Test::Simple is B<explicitly> tested all the way back to perl 5.6.0.
+
+Test::Simple is thread-safe in perl 5.8.1 and up.
+
+=head1 HISTORY
+
+This module was conceived while talking with Tony Bowden in his
+kitchen one night about the problems I was having writing some really
+complicated feature into the new Testing module.  He observed that the
+main problem is not dealing with these edge cases but that people hate
+to write tests B<at all>.  What was needed was a dead simple module
+that took all the hard work out of testing and was really, really easy
+to learn.  Paul Johnson simultaneously had this idea (unfortunately,
+he wasn't in Tony's kitchen).  This is it.
+
+
+=head1 SEE ALSO
+
+=over 4
+
+=item L<Test::More>
+
+More testing functions!  Once you outgrow Test::Simple, look at
+L<Test::More>.  Test::Simple is 100% forward compatible with L<Test::More>
+(i.e. you can just use L<Test::More> instead of Test::Simple in your
+programs and things will still work).
+
+=back
+
+Look in L<Test::More>'s SEE ALSO for more testing modules.
+
+
+=head1 AUTHORS
+
+Idea by Tony Bowden and Paul Johnson, code by Michael G Schwern
+E<lt>schwern@pobox.comE<gt>, wardrobe by Calvin Klein.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright 2001-2008 by Michael G Schwern E<lt>schwern@pobox.comE<gt>.
+
+This program is free software; you can redistribute it and/or 
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut
+
+1;

git/usr/share/perl5/core_perl/Test/Tester.pm

@@ -0,0 +1,693 @@
+use strict;
+
+package Test::Tester;
+
+BEGIN
+{
+	if (*Test::Builder::new{CODE})
+	{
+		warn "You should load Test::Tester before Test::Builder (or anything that loads Test::Builder)"
+	}
+}
+
+use Test::Builder;
+use Test::Tester::CaptureRunner;
+use Test::Tester::Delegate;
+
+require Exporter;
+
+our $VERSION = '1.302210';
+
+our @EXPORT = qw( run_tests check_tests check_test cmp_results show_space );
+our @ISA = qw( Exporter );
+
+my $Test = Test::Builder->new;
+my $Capture = Test::Tester::Capture->new;
+my $Delegator = Test::Tester::Delegate->new;
+$Delegator->{Object} = $Test;
+
+my $runner = Test::Tester::CaptureRunner->new;
+
+my $want_space = $ENV{TESTTESTERSPACE};
+
+sub show_space
+{
+	$want_space = 1;
+}
+
+my $colour = '';
+my $reset = '';
+
+if (my $want_colour = $ENV{TESTTESTERCOLOUR} || $ENV{TESTTESTERCOLOR})
+{
+	if (eval { require Term::ANSIColor; 1 })
+	{
+		eval { require Win32::Console::ANSI } if 'MSWin32' eq $^O;  # support color on windows platforms
+		my ($f, $b) = split(",", $want_colour);
+		$colour = Term::ANSIColor::color($f).Term::ANSIColor::color("on_$b");
+		$reset = Term::ANSIColor::color("reset");
+	}
+
+}
+
+sub new_new
+{
+	return $Delegator;
+}
+
+sub capture
+{
+	return Test::Tester::Capture->new;
+}
+
+sub fh
+{
+	# experiment with capturing output, I don't like it
+	$runner = Test::Tester::FHRunner->new;
+
+	return $Test;
+}
+
+sub find_run_tests
+{
+	my $d = 1;
+	my $found = 0;
+	while ((not $found) and (my ($sub) = (caller($d))[3]) )
+	{
+#		print "$d: $sub\n";
+		$found = ($sub eq "Test::Tester::run_tests");
+		$d++;
+	}
+
+#	die "Didn't find 'run_tests' in caller stack" unless $found;
+	return $d;
+}
+
+sub run_tests
+{
+	local($Delegator->{Object}) = $Capture;
+
+	$runner->run_tests(@_);
+
+	return ($runner->get_premature, $runner->get_results);
+}
+
+sub check_test
+{
+	my $test = shift;
+	my $expect = shift;
+	my $name = shift;
+	$name = "" unless defined($name);
+
+	@_ = ($test, [$expect], $name);
+	goto &check_tests;
+}
+
+sub check_tests
+{
+	my $test = shift;
+	my $expects = shift;
+	my $name = shift;
+	$name = "" unless defined($name);
+
+	my ($prem, @results) = eval { run_tests($test, $name) };
+
+	$Test->ok(! $@, "Test '$name' completed") || $Test->diag($@);
+	$Test->ok(! length($prem), "Test '$name' no premature diagnostication") ||
+		$Test->diag("Before any testing anything, your tests said\n$prem");
+
+	local $Test::Builder::Level = $Test::Builder::Level + 1;
+	cmp_results(\@results, $expects, $name);
+	return ($prem, @results);
+}
+
+sub cmp_field
+{
+	my ($result, $expect, $field, $desc) = @_;
+
+	if (defined $expect->{$field})
+	{
+		$Test->is_eq($result->{$field}, $expect->{$field},
+			"$desc compare $field");
+	}
+}
+
+sub cmp_result
+{
+	my ($result, $expect, $name) = @_;
+
+	my $sub_name = $result->{name};
+	$sub_name = "" unless defined($name);
+
+	my $desc = "subtest '$sub_name' of '$name'";
+
+	{
+		local $Test::Builder::Level = $Test::Builder::Level + 1;
+
+		cmp_field($result, $expect, "ok", $desc);
+
+		cmp_field($result, $expect, "actual_ok", $desc);
+
+		cmp_field($result, $expect, "type", $desc);
+
+		cmp_field($result, $expect, "reason", $desc);
+
+		cmp_field($result, $expect, "name", $desc);
+	}
+
+	# if we got no depth then default to 1
+	my $depth = 1;
+	if (exists $expect->{depth})
+	{
+		$depth = $expect->{depth};
+	}
+
+	# if depth was explicitly undef then don't test it
+	if (defined $depth)
+	{
+		$Test->is_eq($result->{depth}, $depth, "checking depth") ||
+			$Test->diag('You need to change $Test::Builder::Level');
+	}
+
+	if (defined(my $exp = $expect->{diag}))
+	{
+
+        my $got = '';
+        if (ref $exp eq 'Regexp') {
+
+            if (not $Test->like($result->{diag}, $exp,
+                "subtest '$sub_name' of '$name' compare diag"))
+            {
+                $got = $result->{diag};
+            }
+
+        } else {
+
+            # if there actually is some diag then put a \n on the end if it's not
+            # there already
+            $exp .= "\n" if (length($exp) and $exp !~ /\n$/);
+
+            if (not $Test->ok($result->{diag} eq $exp,
+    			"subtest '$sub_name' of '$name' compare diag"))
+            {
+                $got = $result->{diag};
+            }
+        }
+
+        if ($got) {
+    		my $glen = length($got);
+    		my $elen = length($exp);
+    		for ($got, $exp)
+    		{
+    			my @lines = split("\n", $_);
+     			$_ = join("\n", map {
+    				if ($want_space)
+    				{
+    					$_ = $colour.escape($_).$reset;
+    				}
+    				else
+    				{
+    					"'$colour$_$reset'"
+    				}
+    			} @lines);
+    		}
+
+        	$Test->diag(<<EOM);
+Got diag ($glen bytes):
+$got
+Expected diag ($elen bytes):
+$exp
+EOM
+        }
+	}
+}
+
+sub escape
+{
+	my $str = shift;
+	my $res = '';
+	for my $char (split("", $str))
+	{
+		my $c = ord($char);
+		if(($c>32 and $c<125) or $c == 10)
+		{
+			$res .= $char;
+		}
+		else
+		{
+			$res .= sprintf('\x{%x}', $c)
+		}
+	}
+	return $res;
+}
+
+sub cmp_results
+{
+	my ($results, $expects, $name) = @_;
+
+	$Test->is_num(scalar @$results, scalar @$expects, "Test '$name' result count");
+
+	for (my $i = 0; $i < @$expects; $i++)
+	{
+		my $expect = $expects->[$i];
+		my $result = $results->[$i];
+
+		local $Test::Builder::Level = $Test::Builder::Level + 1;
+		cmp_result($result, $expect, $name);
+	}
+}
+
+######## nicked from Test::More
+sub plan {
+	my(@plan) = @_;
+
+	my $caller = caller;
+
+	$Test->exported_to($caller);
+
+	my @imports = ();
+	foreach my $idx (0..$#plan) {
+		if( $plan[$idx] eq 'import' ) {
+			my($tag, $imports) = splice @plan, $idx, 2;
+			@imports = @$imports;
+			last;
+		}
+	}
+
+	$Test->plan(@plan);
+
+	__PACKAGE__->_export_to_level(1, __PACKAGE__, @imports);
+}
+
+sub import {
+	my($class) = shift;
+		{
+			no warnings 'redefine';
+			*Test::Builder::new = \&new_new;
+		}
+	goto &plan;
+}
+
+sub _export_to_level
+{
+        my $pkg = shift;
+	my $level = shift;
+	(undef) = shift;	# redundant arg
+	my $callpkg = caller($level);
+	$pkg->export($callpkg, @_);
+}
+
+
+############
+
+1;
+
+__END__
+
+=head1 NAME
+
+Test::Tester - Ease testing test modules built with Test::Builder
+
+=head1 SYNOPSIS
+
+  use Test::Tester tests => 6;
+
+  use Test::MyStyle;
+
+  check_test(
+    sub {
+      is_mystyle_eq("this", "that", "not eq");
+    },
+    {
+      ok => 0, # expect this to fail
+      name => "not eq",
+      diag => "Expected: 'this'\nGot: 'that'",
+    }
+  );
+
+or
+
+  use Test::Tester tests => 6;
+
+  use Test::MyStyle;
+
+  check_test(
+    sub {
+      is_mystyle_qr("this", "that", "not matching");
+    },
+    {
+      ok => 0, # expect this to fail
+      name => "not matching",
+      diag => qr/Expected: 'this'\s+Got: 'that'/,
+    }
+  );
+
+or
+
+  use Test::Tester;
+
+  use Test::More tests => 3;
+  use Test::MyStyle;
+
+  my ($premature, @results) = run_tests(
+    sub {
+      is_database_alive("dbname");
+    }
+  );
+
+  # now use Test::More::like to check the diagnostic output
+
+  like($results[0]->{diag}, "/^Database ping took \\d+ seconds$"/, "diag");
+
+=head1 DESCRIPTION
+
+If you have written a test module based on Test::Builder then Test::Tester
+allows you to test it with the minimum of effort.
+
+=head1 HOW TO USE (THE EASY WAY)
+
+From version 0.08 Test::Tester no longer requires you to included anything
+special in your test modules. All you need to do is
+
+  use Test::Tester;
+
+in your test script B<before> any other Test::Builder based modules and away
+you go.
+
+Other modules based on Test::Builder can be used to help with the
+testing.  In fact you can even use functions from your module to test
+other functions from the same module (while this is possible it is
+probably not a good idea, if your module has bugs, then
+using it to test itself may give the wrong answers).
+
+The easiest way to test is to do something like
+
+  check_test(
+    sub { is_mystyle_eq("this", "that", "not eq") },
+    {
+      ok => 0, # we expect the test to fail
+      name => "not eq",
+      diag => "Expected: 'this'\nGot: 'that'",
+    }
+  );
+
+this will execute the is_mystyle_eq test, capturing its results and
+checking that they are what was expected.
+
+You may need to examine the test results in a more flexible way, for
+example, the diagnostic output may be quite long or complex or it may involve
+something that you cannot predict in advance like a timestamp. In this case
+you can get direct access to the test results:
+
+  my ($premature, @results) = run_tests(
+    sub {
+      is_database_alive("dbname");
+    }
+  );
+
+  like($result[0]->{diag}, "/^Database ping took \\d+ seconds$"/, "diag");
+
+or
+
+  check_test(
+    sub { is_mystyle_qr("this", "that", "not matching") },
+    {
+      ok => 0, # we expect the test to fail
+      name => "not matching",
+      diag => qr/Expected: 'this'\s+Got: 'that'/,
+    }
+  );
+
+We cannot predict how long the database ping will take so we use
+Test::More's like() test to check that the diagnostic string is of the right
+form.
+
+=head1 HOW TO USE (THE HARD WAY)
+
+I<This is here for backwards compatibility only>
+
+Make your module use the Test::Tester::Capture object instead of the
+Test::Builder one. How to do this depends on your module but assuming that
+your module holds the Test::Builder object in $Test and that all your test
+routines access it through $Test then providing a function something like this
+
+  sub set_builder
+  {
+    $Test = shift;
+  }
+
+should allow your test scripts to do
+
+  Test::YourModule::set_builder(Test::Tester->capture);
+
+and after that any tests inside your module will captured.
+
+=head1 TEST RESULTS
+
+The result of each test is captured in a hash. These hashes are the same as
+the hashes returned by Test::Builder->details but with a couple of extra
+fields.
+
+These fields are documented in L<Test::Builder> in the details() function
+
+=over 2
+
+=item ok
+
+Did the test pass?
+
+=item actual_ok
+
+Did the test really pass? That is, did the pass come from
+Test::Builder->ok() or did it pass because it was a TODO test?
+
+=item name
+
+The name supplied for the test.
+
+=item type
+
+What kind of test? Possibilities include, skip, todo etc. See
+L<Test::Builder> for more details.
+
+=item reason
+
+The reason for the skip, todo etc. See L<Test::Builder> for more details.
+
+=back
+
+These fields are exclusive to Test::Tester.
+
+=over 2
+
+=item diag
+
+Any diagnostics that were output for the test. This only includes
+diagnostics output B<after> the test result is declared.
+
+Note that Test::Builder ensures that any diagnostics end in a \n and
+it in earlier versions of Test::Tester it was essential that you have
+the final \n in your expected diagnostics. From version 0.10 onward,
+Test::Tester will add the \n if you forgot it. It will not add a \n if
+you are expecting no diagnostics. See below for help tracking down
+hard to find space and tab related problems.
+
+=item depth
+
+This allows you to check that your test module is setting the correct value
+for $Test::Builder::Level and thus giving the correct file and line number
+when a test fails. It is calculated by looking at caller() and
+$Test::Builder::Level. It should count how many subroutines there are before
+jumping into the function you are testing. So for example in
+
+  run_tests( sub { my_test_function("a", "b") } );
+
+the depth should be 1 and in
+
+  sub deeper { my_test_function("a", "b") }
+
+  run_tests(sub { deeper() });
+
+depth should be 2, that is 1 for the sub {} and one for deeper(). This
+might seem a little complex but if your tests look like the simple
+examples in this doc then you don't need to worry as the depth will
+always be 1 and that's what Test::Tester expects by default.
+
+B<Note>: if you do not specify a value for depth in check_test() then it
+automatically compares it against 1, if you really want to skip the depth
+test then pass in undef.
+
+B<Note>: depth will not be correctly calculated for tests that run from a
+signal handler or an END block or anywhere else that hides the call stack.
+
+=back
+
+Some of Test::Tester's functions return arrays of these hashes, just
+like Test::Builder->details. That is, the hash for the first test will
+be array element 1 (not 0). Element 0 will not be a hash it will be a
+string which contains any diagnostic output that came before the first
+test. This should usually be empty, if it's not, it means something
+output diagnostics before any test results showed up.
+
+=head1 SPACES AND TABS
+
+Appearances can be deceptive, especially when it comes to emptiness. If you
+are scratching your head trying to work out why Test::Tester is saying that
+your diagnostics are wrong when they look perfectly right then the answer is
+probably whitespace. From version 0.10 on, Test::Tester surrounds the
+expected and got diag values with single quotes to make it easier to spot
+trailing whitespace. So in this example
+
+  # Got diag (5 bytes):
+  # 'abcd '
+  # Expected diag (4 bytes):
+  # 'abcd'
+
+it is quite clear that there is a space at the end of the first string.
+Another way to solve this problem is to use colour and inverse video on an
+ANSI terminal, see below COLOUR below if you want this.
+
+Unfortunately this is sometimes not enough, neither colour nor quotes will
+help you with problems involving tabs, other non-printing characters and
+certain kinds of problems inherent in Unicode. To deal with this, you can
+switch Test::Tester into a mode whereby all "tricky" characters are shown as
+\{xx}. Tricky characters are those with ASCII code less than 33 or higher
+than 126. This makes the output more difficult to read but much easier to
+find subtle differences between strings. To turn on this mode either call
+C<show_space()> in your test script or set the C<TESTTESTERSPACE> environment
+variable to be a true value. The example above would then look like
+
+  # Got diag (5 bytes):
+  # abcd\x{20}
+  # Expected diag (4 bytes):
+  # abcd
+
+=head1 COLOUR
+
+If you prefer to use colour as a means of finding tricky whitespace
+characters then you can set the C<TESTTESTCOLOUR> environment variable to a
+comma separated pair of colours, the first for the foreground, the second
+for the background. For example "white,red" will print white text on a red
+background. This requires the Term::ANSIColor module. You can specify any
+colour that would be acceptable to the Term::ANSIColor::color function.
+
+If you spell colour differently, that's no problem. The C<TESTTESTERCOLOR>
+variable also works (if both are set then the British spelling wins out).
+
+=head1 EXPORTED FUNCTIONS
+
+=head3 ($premature, @results) = run_tests(\&test_sub)
+
+\&test_sub is a reference to a subroutine.
+
+run_tests runs the subroutine in $test_sub and captures the results of any
+tests inside it. You can run more than 1 test inside this subroutine if you
+like.
+
+$premature is a string containing any diagnostic output from before
+the first test.
+
+@results is an array of test result hashes.
+
+=head3 cmp_result(\%result, \%expect, $name)
+
+\%result is a ref to a test result hash.
+
+\%expect is a ref to a hash of expected values for the test result.
+
+cmp_result compares the result with the expected values. If any differences
+are found it outputs diagnostics. You may leave out any field from the
+expected result and cmp_result will not do the comparison of that field.
+
+=head3 cmp_results(\@results, \@expects, $name)
+
+\@results is a ref to an array of test results.
+
+\@expects is a ref to an array of hash refs.
+
+cmp_results checks that the results match the expected results and if any
+differences are found it outputs diagnostics. It first checks that the
+number of elements in \@results and \@expects is the same. Then it goes
+through each result checking it against the expected result as in
+cmp_result() above.
+
+=head3 ($premature, @results) = check_tests(\&test_sub, \@expects, $name)
+
+\&test_sub is a reference to a subroutine.
+
+\@expect is a ref to an array of hash refs which are expected test results.
+
+check_tests combines run_tests and cmp_tests into a single call. It also
+checks if the tests died at any stage.
+
+It returns the same values as run_tests, so you can further examine the test
+results if you need to.
+
+=head3 ($premature, @results) = check_test(\&test_sub, \%expect, $name)
+
+\&test_sub is a reference to a subroutine.
+
+\%expect is a ref to an hash of expected values for the test result.
+
+check_test is a wrapper around check_tests. It combines run_tests and
+cmp_tests into a single call, checking if the test died. It assumes
+that only a single test is run inside \&test_sub and include a test to
+make sure this is true.
+
+It returns the same values as run_tests, so you can further examine the test
+results if you need to.
+
+=head3 show_space()
+
+Turn on the escaping of characters as described in the SPACES AND TABS
+section.
+
+=head1 HOW IT WORKS
+
+Normally, a test module (let's call it Test:MyStyle) calls
+Test::Builder->new to get the Test::Builder object. Test::MyStyle calls
+methods on this object to record information about test results. When
+Test::Tester is loaded, it replaces Test::Builder's new() method with one
+which returns a Test::Tester::Delegate object. Most of the time this object
+behaves as the real Test::Builder object. Any methods that are called are
+delegated to the real Test::Builder object so everything works perfectly.
+However once we go into test mode, the method calls are no longer passed to
+the real Test::Builder object, instead they go to the Test::Tester::Capture
+object. This object seems exactly like the real Test::Builder object,
+except, instead of outputting test results and diagnostics, it just records
+all the information for later analysis.
+
+=head1 CAVEATS
+
+Support for calling Test::Builder->note is minimal. It's implemented
+as an empty stub, so modules that use it will not crash but the calls
+are not recorded for testing purposes like the others. Patches
+welcome.
+
+=head1 SEE ALSO
+
+L<Test::Builder> the source of testing goodness. L<Test::Builder::Tester>
+for an alternative approach to the problem tackled by Test::Tester -
+captures the strings output by Test::Builder. This means you cannot get
+separate access to the individual pieces of information and you must predict
+B<exactly> what your test will output.
+
+=head1 AUTHOR
+
+This module is copyright 2005 Fergal Daly <fergal@esatclear.ie>, some parts
+are based on other people's work.
+
+Plan handling lifted from Test::More. written by Michael G Schwern
+<schwern@pobox.com>.
+
+Test::Tester::Capture is a cut down and hacked up version of Test::Builder.
+Test::Builder was written by chromatic <chromatic@wgz.org> and Michael G
+Schwern <schwern@pobox.com>.
+
+=head1 LICENSE
+
+Under the same license as Perl itself
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/API.pm

@@ -0,0 +1,1785 @@
+package Test2::API;
+use strict;
+use warnings;
+
+use Time::HiRes qw/time/;
+use Test2::Util qw/USE_THREADS/;
+
+BEGIN {
+    $ENV{TEST_ACTIVE} ||= 1;
+    $ENV{TEST2_ACTIVE} = 1;
+}
+
+our $VERSION = '1.302210';
+
+
+my $INST;
+my $ENDING = 0;
+sub test2_unset_is_end { $ENDING = 0 }
+sub test2_get_is_end { $ENDING }
+
+sub test2_set_is_end {
+    my $before = $ENDING;
+    ($ENDING) = @_ ? @_ : (1);
+
+    # Only send the event in a transition from false to true
+    return if $before;
+    return unless $ENDING;
+
+    return unless $INST;
+    my $stack = $INST->stack or return;
+    my $root = $stack->root or return;
+
+    return unless $root->count;
+
+    return unless $$ == $INST->pid;
+    return unless get_tid() == $INST->tid;
+
+    my $trace = Test2::EventFacet::Trace->new(
+        frame  => [__PACKAGE__, __FILE__, __LINE__, __PACKAGE__ . '::test2_set_is_end'],
+    );
+    my $ctx = Test2::API::Context->new(
+        trace => $trace,
+        hub   => $root,
+    );
+
+    $ctx->send_ev2(control => { phase => 'END', details => 'Transition to END phase' });
+
+    1;
+}
+
+use Test2::API::Instance(\$INST);
+
+# Set the exit status
+END {
+    test2_set_is_end(); # See gh #16
+    $INST->set_exit();
+}
+
+sub CLONE {
+    my $init = test2_init_done();
+    my $load = test2_load_done();
+
+    return if $init && $load;
+
+    require Carp;
+    Carp::croak "Test2 must be fully loaded before you start a new thread!\n";
+}
+
+# See gh #16
+{
+    no warnings;
+    INIT { eval 'END { test2_set_is_end() }; 1' or die $@ }
+}
+
+BEGIN {
+    no warnings 'once';
+    if("$]" >= 5.014 || $ENV{T2_CHECK_DEPTH} || $Test2::API::DO_DEPTH_CHECK) {
+        *DO_DEPTH_CHECK = sub() { 1 };
+    }
+    else {
+        *DO_DEPTH_CHECK = sub() { 0 };
+    }
+}
+
+use Test2::EventFacet::Trace();
+use Test2::Util::Trace(); # Legacy
+
+use Test2::Hub::Subtest();
+use Test2::Hub::Interceptor();
+use Test2::Hub::Interceptor::Terminator();
+
+use Test2::Event::Ok();
+use Test2::Event::Diag();
+use Test2::Event::Note();
+use Test2::Event::Plan();
+use Test2::Event::Bail();
+use Test2::Event::Exception();
+use Test2::Event::Waiting();
+use Test2::Event::Skip();
+use Test2::Event::Subtest();
+
+use Carp qw/carp croak confess/;
+use Scalar::Util qw/blessed weaken/;
+use Test2::Util qw/get_tid clone_io pkg_to_file gen_uid/;
+
+our @EXPORT_OK = qw{
+    context release
+    context_do
+    no_context
+    intercept intercept_deep
+    run_subtest
+
+    test2_init_done
+    test2_load_done
+    test2_load
+    test2_start_preload
+    test2_stop_preload
+    test2_in_preload
+    test2_is_testing_done
+
+    test2_set_is_end
+    test2_unset_is_end
+    test2_get_is_end
+
+    test2_pid
+    test2_tid
+    test2_stack
+    test2_no_wait
+    test2_ipc_wait_enable
+    test2_ipc_wait_disable
+    test2_ipc_wait_enabled
+
+    test2_add_uuid_via
+
+    test2_add_callback_testing_done
+
+    test2_add_callback_context_aquire
+    test2_add_callback_context_acquire
+    test2_add_callback_context_init
+    test2_add_callback_context_release
+    test2_add_callback_exit
+    test2_add_callback_post_load
+    test2_add_callback_pre_subtest
+    test2_list_context_aquire_callbacks
+    test2_list_context_acquire_callbacks
+    test2_list_context_init_callbacks
+    test2_list_context_release_callbacks
+    test2_list_exit_callbacks
+    test2_list_post_load_callbacks
+    test2_list_pre_subtest_callbacks
+
+    test2_ipc
+    test2_has_ipc
+    test2_ipc_disable
+    test2_ipc_disabled
+    test2_ipc_drivers
+    test2_ipc_add_driver
+    test2_ipc_polling
+    test2_ipc_disable_polling
+    test2_ipc_enable_polling
+    test2_ipc_get_pending
+    test2_ipc_set_pending
+    test2_ipc_get_timeout
+    test2_ipc_set_timeout
+
+    test2_formatter
+    test2_formatters
+    test2_formatter_add
+    test2_formatter_set
+
+    test2_stdout
+    test2_stderr
+    test2_reset_io
+
+    test2_enable_trace_stamps
+    test2_disable_trace_stamps
+    test2_trace_stamps_enabled
+
+    test2_add_pending_diag
+    test2_get_pending_diags
+    test2_clear_pending_diags
+};
+BEGIN { require Exporter; our @ISA = qw(Exporter) }
+
+my @PENDING_DIAGS;
+
+sub test2_add_pending_diag { push @PENDING_DIAGS => @_ }
+sub test2_get_pending_diags { @PENDING_DIAGS }
+sub test2_clear_pending_diags { my @out = @PENDING_DIAGS; @PENDING_DIAGS = (); return @out }
+
+my $STACK       = $INST->stack;
+my $CONTEXTS    = $INST->contexts;
+my $INIT_CBS    = $INST->context_init_callbacks;
+my $ACQUIRE_CBS = $INST->context_acquire_callbacks;
+
+my $STDOUT = clone_io(\*STDOUT);
+my $STDERR = clone_io(\*STDERR);
+sub test2_stdout { $STDOUT ||= clone_io(\*STDOUT) }
+sub test2_stderr { $STDERR ||= clone_io(\*STDERR) }
+
+sub test2_post_preload_reset {
+    test2_reset_io();
+    $INST->post_preload_reset;
+}
+
+sub test2_reset_io {
+    $STDOUT = clone_io(\*STDOUT);
+    $STDERR = clone_io(\*STDERR);
+}
+
+sub test2_init_done { $INST->finalized }
+sub test2_load_done { $INST->loaded }
+
+sub test2_load          { $INST->load }
+sub test2_start_preload { $ENV{T2_IN_PRELOAD} = 1; $INST->start_preload }
+sub test2_stop_preload  { $ENV{T2_IN_PRELOAD} = 0; $INST->stop_preload }
+sub test2_in_preload    { $INST->preload }
+
+sub test2_pid              { $INST->pid }
+sub test2_tid              { $INST->tid }
+sub test2_stack            { $INST->stack }
+sub test2_ipc_wait_enable  { $INST->set_no_wait(0) }
+sub test2_ipc_wait_disable { $INST->set_no_wait(1) }
+sub test2_ipc_wait_enabled { !$INST->no_wait }
+
+sub test2_enable_trace_stamps  { $INST->test2_enable_trace_stamps }
+sub test2_disable_trace_stamps { $INST->test2_disable_trace_stamps }
+sub test2_trace_stamps_enabled { $INST->test2_trace_stamps_enabled }
+
+sub test2_is_testing_done {
+    # No instance? VERY DONE!
+    return 1 unless $INST;
+
+    # No stack? tests must be done, it is created pretty early
+    my $stack = $INST->stack or return 1;
+
+    # Nothing on the stack, no root hub yet, likely have not started testing
+    return 0 unless @$stack;
+
+    # Stack has a slot for the root hub (see above) but it is undefined, likely
+    # garbage collected, test is done
+    my $root_hub = $stack->[0] or return 1;
+
+    # If the root hub is ended than testing is done.
+    return 1 if $root_hub->ended;
+
+    # Looks like we are still testing!
+    return 0;
+}
+
+sub test2_no_wait {
+    $INST->set_no_wait(@_) if @_;
+    $INST->no_wait;
+}
+
+sub test2_add_callback_testing_done {
+    my $cb = shift;
+
+    test2_add_callback_post_load(sub {
+        my $stack = test2_stack();
+        $stack->top; # Ensure we have a hub
+        my ($hub) = Test2::API::test2_stack->all;
+
+        $hub->set_active(1);
+
+        $hub->follow_up($cb);
+    });
+
+    return;
+}
+
+sub test2_add_callback_context_acquire   { $INST->add_context_acquire_callback(@_) }
+sub test2_add_callback_context_aquire    { $INST->add_context_acquire_callback(@_) }
+sub test2_add_callback_context_init      { $INST->add_context_init_callback(@_) }
+sub test2_add_callback_context_release   { $INST->add_context_release_callback(@_) }
+sub test2_add_callback_exit              { $INST->add_exit_callback(@_) }
+sub test2_add_callback_post_load         { $INST->add_post_load_callback(@_) }
+sub test2_add_callback_pre_subtest       { $INST->add_pre_subtest_callback(@_) }
+sub test2_list_context_aquire_callbacks  { @{$INST->context_acquire_callbacks} }
+sub test2_list_context_acquire_callbacks { @{$INST->context_acquire_callbacks} }
+sub test2_list_context_init_callbacks    { @{$INST->context_init_callbacks} }
+sub test2_list_context_release_callbacks { @{$INST->context_release_callbacks} }
+sub test2_list_exit_callbacks            { @{$INST->exit_callbacks} }
+sub test2_list_post_load_callbacks       { @{$INST->post_load_callbacks} }
+sub test2_list_pre_subtest_callbacks     { @{$INST->pre_subtest_callbacks} }
+
+sub test2_add_uuid_via {
+    $INST->set_add_uuid_via(@_) if @_;
+    $INST->add_uuid_via();
+}
+
+sub test2_ipc                 { $INST->ipc }
+sub test2_has_ipc             { $INST->has_ipc }
+sub test2_ipc_disable         { $INST->ipc_disable }
+sub test2_ipc_disabled        { $INST->ipc_disabled }
+sub test2_ipc_add_driver      { $INST->add_ipc_driver(@_) }
+sub test2_ipc_drivers         { @{$INST->ipc_drivers} }
+sub test2_ipc_polling         { $INST->ipc_polling }
+sub test2_ipc_enable_polling  { $INST->enable_ipc_polling }
+sub test2_ipc_disable_polling { $INST->disable_ipc_polling }
+sub test2_ipc_get_pending     { $INST->get_ipc_pending }
+sub test2_ipc_set_pending     { $INST->set_ipc_pending(@_) }
+sub test2_ipc_set_timeout     { $INST->set_ipc_timeout(@_) }
+sub test2_ipc_get_timeout     { $INST->ipc_timeout() }
+sub test2_ipc_enable_shm      { 0 }
+
+sub test2_formatter     {
+    if ($ENV{T2_FORMATTER} && $ENV{T2_FORMATTER} =~ m/^(\+)?(.*)$/) {
+        my $formatter = $1 ? $2 : "Test2::Formatter::$2";
+        my $file = pkg_to_file($formatter);
+        require $file;
+        return $formatter;
+    }
+
+    return $INST->formatter;
+}
+
+sub test2_formatters    { @{$INST->formatters} }
+sub test2_formatter_add { $INST->add_formatter(@_) }
+sub test2_formatter_set {
+    my ($formatter) = @_;
+    croak "No formatter specified" unless $formatter;
+    croak "Global Formatter already set" if $INST->formatter_set;
+    $INST->set_formatter($formatter);
+}
+
+# Private, for use in Test2::API::Context
+sub _contexts_ref                  { $INST->contexts }
+sub _context_acquire_callbacks_ref { $INST->context_acquire_callbacks }
+sub _context_init_callbacks_ref    { $INST->context_init_callbacks }
+sub _context_release_callbacks_ref { $INST->context_release_callbacks }
+sub _add_uuid_via_ref              { \($INST->{Test2::API::Instance::ADD_UUID_VIA()}) }
+
+# Private, for use in Test2::IPC
+sub _set_ipc { $INST->set_ipc(@_) }
+
+sub context_do(&;@) {
+    my $code = shift;
+    my @args = @_;
+
+    my $ctx = context(level => 1);
+
+    my $want = wantarray;
+
+    my @out;
+    my $ok = eval {
+        $want          ? @out    = $code->($ctx, @args) :
+        defined($want) ? $out[0] = $code->($ctx, @args) :
+                                   $code->($ctx, @args) ;
+        1;
+    };
+    my $err = $@;
+
+    $ctx->release;
+
+    die $err unless $ok;
+
+    return @out    if $want;
+    return $out[0] if defined $want;
+    return;
+}
+
+sub no_context(&;$) {
+    my ($code, $hid) = @_;
+    $hid ||= $STACK->top->hid;
+
+    my $ctx = $CONTEXTS->{$hid};
+    delete $CONTEXTS->{$hid};
+    my $ok = eval { $code->(); 1 };
+    my $err = $@;
+
+    $CONTEXTS->{$hid} = $ctx;
+    weaken($CONTEXTS->{$hid});
+
+    die $err unless $ok;
+
+    return;
+};
+
+my $UUID_VIA = _add_uuid_via_ref();
+sub context {
+    # We need to grab these before anything else to ensure they are not
+    # changed.
+    my ($errno, $eval_error, $child_error, $extended_error) = (0 + $!, $@, $?, $^E);
+
+    my %params = (level => 0, wrapped => 0, @_);
+
+    # If something is getting a context then the sync system needs to be
+    # considered loaded...
+    $INST->load unless $INST->{loaded};
+
+    croak "context() called, but return value is ignored"
+        unless defined wantarray;
+
+    my $stack   = $params{stack} || $STACK;
+    my $hub     = $params{hub}   || (@$stack ? $stack->[-1] : $stack->top);
+
+    # Catch an edge case where we try to get context after the root hub has
+    # been garbage collected resulting in a stack that has a single undef
+    # hub
+    if (!($hub && $hub->{hid}) && !exists($params{hub}) && @$stack) {
+        my $msg;
+
+        if ($hub && !$hub->{hid}) {
+            $msg = Carp::longmess("$hub has no hid! (did you attempt a testing event after done_testing?). You may be relying on a tool or plugin that was based off an old Test2 that did not require hids.");
+        }
+        else {
+            $msg = Carp::longmess("Attempt to get Test2 context after testing has completed (did you attempt a testing event after done_testing?)");
+        }
+
+        # The error message is usually masked by the global destruction, so we have to print to STDER
+        print STDERR $msg;
+
+        # Make sure this is a failure, we are probably already in END, so set $? to change the exit code
+        $? = 1;
+
+        # Now we actually die to interrupt the program flow and avoid undefined his warnings
+        die $msg;
+    }
+
+    my $hid     = $hub->{hid};
+    my $current = $CONTEXTS->{$hid};
+
+    $_->(\%params) for @$ACQUIRE_CBS;
+    map $_->(\%params), @{$hub->{_context_acquire}} if $hub->{_context_acquire};
+
+    # This is for https://github.com/Test-More/test-more/issues/16
+    # and https://rt.perl.org/Public/Bug/Display.html?id=127774
+    my $phase = ${^GLOBAL_PHASE} || 'NA';
+    my $end_phase = $ENDING || $phase eq 'END' || $phase eq 'DESTRUCT';
+
+    my $level = 1 + $params{level};
+    my ($pkg, $file, $line, $sub, @other) = $end_phase ? caller(0) : caller($level);
+    unless ($pkg || $end_phase) {
+        confess "Could not find context at depth $level" unless $params{fudge};
+        ($pkg, $file, $line, $sub, @other) = caller(--$level) while ($level >= 0 && !$pkg);
+    }
+
+    my $depth = $level;
+    $depth++ while DO_DEPTH_CHECK && !$end_phase && (!$current || $depth <= $current->{_depth} + $params{wrapped}) && caller($depth + 1);
+    $depth -= $params{wrapped};
+    my $depth_ok = !DO_DEPTH_CHECK || $end_phase || !$current || $current->{_depth} < $depth;
+
+    if ($current && $params{on_release} && $depth_ok) {
+        $current->{_on_release} ||= [];
+        push @{$current->{_on_release}} => $params{on_release};
+    }
+
+    # I know this is ugly....
+    ($!, $@, $?, $^E) = ($errno, $eval_error, $child_error, $extended_error) and return bless(
+        {
+            %$current,
+            _is_canon   => undef,
+            errno       => $errno,
+            eval_error  => $eval_error,
+            child_error => $child_error,
+            _is_spawn   => [$pkg, $file, $line, $sub],
+            _start_fail_count => $hub->{failed} || 0,
+        },
+        'Test2::API::Context'
+    ) if $current && $depth_ok;
+
+    # Handle error condition of bad level
+    if ($current) {
+        unless (${$current->{_aborted}}) {
+            _canon_error($current, [$pkg, $file, $line, $sub, $depth])
+                unless $current->{_is_canon};
+
+            _depth_error($current, [$pkg, $file, $line, $sub, $depth])
+                unless $depth_ok;
+        }
+
+        $current->release if $current->{_is_canon};
+
+        delete $CONTEXTS->{$hid};
+    }
+
+    # Directly bless the object here, calling new is a noticeable performance
+    # hit with how often this needs to be called.
+    my $trace = bless(
+        {
+            frame  => [$pkg, $file, $line, $sub],
+            pid    => $$,
+            tid    => get_tid(),
+            cid    => gen_uid(),
+            hid    => $hid,
+            nested => $hub->{nested},
+            buffered => $hub->{buffered},
+
+            full_caller => [$pkg, $file, $line, $sub, @other],
+
+            $INST->{trace_stamps} ? (stamp => time()) : (),
+
+            $$UUID_VIA ? (
+                huuid => $hub->{uuid},
+                uuid  => ${$UUID_VIA}->('context'),
+            ) : (),
+        },
+        'Test2::EventFacet::Trace'
+    );
+
+    # Directly bless the object here, calling new is a noticeable performance
+    # hit with how often this needs to be called.
+    my $aborted = 0;
+    $current = bless(
+        {
+            _aborted          => \$aborted,
+            stack             => $stack,
+            hub               => $hub,
+            trace             => $trace,
+            _is_canon         => 1,
+            _depth            => $depth,
+            errno             => $errno,
+            eval_error        => $eval_error,
+            child_error       => $child_error,
+            _start_fail_count => $hub->{failed} || 0,
+            $params{on_release} ? (_on_release => [$params{on_release}]) : (),
+        },
+        'Test2::API::Context'
+    );
+
+    $CONTEXTS->{$hid} = $current;
+    weaken($CONTEXTS->{$hid});
+
+    $_->($current) for @$INIT_CBS;
+    map $_->($current), @{$hub->{_context_init}} if $hub->{_context_init};
+
+    $params{on_init}->($current) if $params{on_init};
+
+    ($!, $@, $?, $^E) = ($errno, $eval_error, $child_error, $extended_error);
+
+    return $current;
+}
+
+sub _depth_error {
+    _existing_error(@_, <<"    EOT");
+context() was called to retrieve an existing context, however the existing
+context was created in a stack frame at the same, or deeper level. This usually
+means that a tool failed to release the context when it was finished.
+    EOT
+}
+
+sub _canon_error {
+    _existing_error(@_, <<"    EOT");
+context() was called to retrieve an existing context, however the existing
+context has an invalid internal state (!_canon_count). This should not normally
+happen unless something is mucking about with internals...
+    EOT
+}
+
+sub _existing_error {
+    my ($ctx, $details, $msg) = @_;
+    my ($pkg, $file, $line, $sub, $depth) = @$details;
+
+    my $oldframe = $ctx->{trace}->frame;
+    my $olddepth = $ctx->{_depth};
+
+    # Older versions of Carp do not export longmess() function, so it needs to be called with package name
+    my $mess = Carp::longmess();
+
+    warn <<"    EOT";
+$msg
+Old context details:
+   File: $oldframe->[1]
+   Line: $oldframe->[2]
+   Tool: $oldframe->[3]
+  Depth: $olddepth
+
+New context details:
+   File: $file
+   Line: $line
+   Tool: $sub
+  Depth: $depth
+
+Trace: $mess
+
+Removing the old context and creating a new one...
+    EOT
+}
+
+sub release($;$) {
+    $_[0]->release;
+    return $_[1];
+}
+
+sub intercept(&) {
+    my $code = shift;
+    my $ctx = context();
+
+    my $events = _intercept($code, deep => 0);
+
+    $ctx->release;
+
+    return $events;
+}
+
+sub intercept_deep(&) {
+    my $code = shift;
+    my $ctx = context();
+
+    my $events = _intercept($code, deep => 1);
+
+    $ctx->release;
+
+    return $events;
+}
+
+sub _intercept {
+    my $code = shift;
+    my %params = @_;
+    my $ctx = context();
+
+    my $ipc;
+    if (my $global_ipc = test2_ipc()) {
+        my $driver = blessed($global_ipc);
+        $ipc = $driver->new;
+    }
+
+    my $hub = Test2::Hub::Interceptor->new(
+        ipc => $ipc,
+        no_ending => 1,
+    );
+
+    my @events;
+    $hub->listen(sub { push @events => $_[1] }, inherit => $params{deep});
+
+    $ctx->stack->top; # Make sure there is a top hub before we begin.
+    $ctx->stack->push($hub);
+
+    my $trace = $ctx->trace;
+    my $state = {};
+    $hub->clean_inherited(trace => $trace, state => $state);
+
+    my ($ok, $err) = (1, undef);
+    T2_SUBTEST_WRAPPER: {
+        # Do not use 'try' cause it localizes __DIE__
+        $ok = eval { $code->(hub => $hub, context => $ctx->snapshot); 1 };
+        $err = $@;
+
+        # They might have done 'BEGIN { skip_all => "whatever" }'
+        if (!$ok && $err =~ m/Label not found for "last T2_SUBTEST_WRAPPER"/ || (blessed($err) && $err->isa('Test2::Hub::Interceptor::Terminator'))) {
+            $ok  = 1;
+            $err = undef;
+        }
+    }
+
+    $hub->cull;
+    $ctx->stack->pop($hub);
+
+    $hub->restore_inherited(trace => $trace, state => $state);
+
+    $ctx->release;
+
+    die $err unless $ok;
+
+    $hub->finalize($trace, 1)
+        if $ok
+        && !$hub->no_ending
+        && !$hub->ended;
+
+    require Test2::API::InterceptResult;
+    return Test2::API::InterceptResult->new_from_ref(\@events);
+}
+
+sub run_subtest {
+    my ($name, $code, $params, @args) = @_;
+
+    $_->($name,$code,@args)
+        for Test2::API::test2_list_pre_subtest_callbacks();
+
+    $params = {buffered => $params} unless ref $params;
+    my $inherit_trace = delete $params->{inherit_trace};
+
+    my $ctx = context();
+
+    my $parent = $ctx->hub;
+
+    # If a parent is buffered then the child must be as well.
+    my $buffered = $params->{buffered} || $parent->{buffered};
+
+    $ctx->note($name) unless $buffered;
+
+    my $stack = $ctx->stack || $STACK;
+    my $hub = $stack->new_hub(
+        class => 'Test2::Hub::Subtest',
+        %$params,
+        buffered => $buffered,
+    );
+
+    my @events;
+    $hub->listen(sub { push @events => $_[1] });
+
+    if ($buffered) {
+        if (my $format = $hub->format) {
+            my $hide = $format->can('hide_buffered') ? $format->hide_buffered : 1;
+            $hub->format(undef) if $hide;
+        }
+    }
+
+    if ($inherit_trace) {
+        my $orig = $code;
+        $code = sub {
+            my $base_trace = $ctx->trace;
+            my $trace = $base_trace->snapshot(nested => 1 + $base_trace->nested);
+            my $st_ctx = Test2::API::Context->new(
+                trace  => $trace,
+                hub    => $hub,
+            );
+            $st_ctx->do_in_context($orig, @args);
+        };
+    }
+
+    my $start_stamp = time;
+
+    my ($ok, $err, $finished);
+    T2_SUBTEST_WRAPPER: {
+        # Do not use 'try' cause it localizes __DIE__
+        $ok = eval { $code->(@args); 1 };
+        $err = $@;
+
+        # They might have done 'BEGIN { skip_all => "whatever" }'
+        if (!$ok && $err =~ m/Label not found for "last T2_SUBTEST_WRAPPER"/ || (blessed($err) && blessed($err) eq 'Test::Builder::Exception')) {
+            $ok  = undef;
+            $err = undef;
+        }
+        else {
+            $finished = 1;
+        }
+    }
+
+    my $stop_stamp = time;
+
+    if ($params->{no_fork}) {
+        if ($$ != $ctx->trace->pid) {
+            warn $ok ? "Forked inside subtest, but subtest never finished!\n" : $err;
+            exit 255;
+        }
+
+        if (get_tid() != $ctx->trace->tid) {
+            warn $ok ? "Started new thread inside subtest, but thread never finished!\n" : $err;
+            exit 255;
+        }
+    }
+    elsif (!$parent->is_local && !$parent->ipc) {
+        warn $ok ? "A new process or thread was started inside subtest, but IPC is not enabled!\n" : $err;
+        exit 255;
+    }
+
+    $stack->pop($hub);
+
+    my $trace = $ctx->trace;
+
+    my $bailed = $hub->bailed_out;
+
+    if (!$finished) {
+        if ($bailed && !$buffered) {
+            $ctx->bail($bailed->reason);
+        }
+        elsif ($bailed && $buffered) {
+            $ok = 1;
+        }
+        else {
+            my $code = $hub->exit_code;
+            $ok = !$code;
+            $err = "Subtest ended with exit code $code" if $code;
+        }
+    }
+
+    $hub->finalize($trace->snapshot(huuid => $hub->uuid, hid => $hub->hid, nested => $hub->nested, buffered => $buffered), 1)
+        if $ok
+        && !$hub->no_ending
+        && !$hub->ended;
+
+    my $pass = $ok && $hub->is_passing;
+    my $e = $ctx->build_event(
+        'Subtest',
+        pass         => $pass,
+        name         => $name,
+        subtest_id   => $hub->id,
+        subtest_uuid => $hub->uuid,
+        buffered     => $buffered,
+        subevents    => \@events,
+        start_stamp  => $start_stamp,
+        stop_stamp   => $stop_stamp,
+    );
+
+    my $plan_ok = $hub->check_plan;
+
+    $ctx->hub->send($e);
+
+    $ctx->failure_diag($e) unless $e->pass;
+
+    $ctx->diag("Caught exception in subtest: $err") unless $ok;
+
+    $ctx->diag("Bad subtest plan, expected " . $hub->plan . " but ran " . $hub->count)
+        if defined($plan_ok) && !$plan_ok;
+
+    $ctx->bail($bailed->reason) if $bailed && $buffered;
+
+    $ctx->release;
+    return $pass;
+}
+
+# There is a use-cycle between API and API/Context. Context needs to use some
+# API functions as the package is compiling. Test2::API::context() needs
+# Test2::API::Context to be loaded, but we cannot 'require' the module there as
+# it causes a very noticeable performance impact with how often context() is
+# called.
+require Test2::API::Context;
+
+# If the env var was set to load plugins, load them now, this is the earliest
+# safe point to do so.
+if (my $plugins = $ENV{TEST2_ENABLE_PLUGINS}) {
+    for my $p (split /\s*,\s*/, $plugins) {
+        $p = "Test2::Plugin::$p" unless $p =~ s/^\+//;
+        my $mod = "$p.pm";
+        $mod =~ s{::}{/}g;
+
+        if ($ENV{HARNESS_IS_VERBOSE} || !$ENV{HARNESS_ACTIVE}) {
+            # If the harness is verbose then just display the message for all to
+            # see. It is nice info and they already asked for noisy output.
+
+            test2_add_callback_post_load(sub {
+                test2_stack()->top; # Ensure we have at least 1 hub.
+                my ($hub) = test2_stack()->all;
+                $hub->send(
+                    Test2::Event::Note->new(
+                        trace => Test2::Util::Trace->new(frame => [__PACKAGE__, __FILE__, __LINE__, $p]),
+                        message => "Loaded plugin '$p' as specified in the TEST2_ENABLE_PLUGINS env var.",
+                    ),
+                );
+            });
+        }
+
+        eval {
+            package main;
+            require $mod;
+            $p->import;
+            1
+        } or die "Could not load plugin '$p', which was specified in the TEST2_ENABLE_PLUGINS env var ($plugins): $@";
+    }
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::API - Primary interface for writing Test2 based testing tools.
+
+=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 (once there is
+a stable release), but the underlying implementation details might.
+B<Do not break encapsulation here!>
+
+Currently the implementation is to create a single instance of the
+L<Test2::API::Instance> Object. All class methods defer to the single
+instance. There is no public access to the singleton, and that is intentional.
+The class methods provided by this package provide the only functionality
+publicly exposed.
+
+This is done primarily to avoid the problems Test::Builder had by exposing its
+singleton. We do not want anyone to replace this singleton, rebless it, or
+directly muck with its internals. If you need to do something and cannot
+because of the restrictions placed here, then please report it as an issue. If
+possible, we will create a way for you to implement your functionality without
+exposing things that should not be exposed.
+
+=head1 DESCRIPTION
+
+This package exports all the functions necessary to write and/or verify testing
+tools. Using these building blocks you can begin writing test tools very
+quickly. You are also provided with tools that help you to test the tools you
+write.
+
+=head1 SYNOPSIS
+
+=head2 WRITING A TOOL
+
+The C<context()> method is your primary interface into the Test2 framework.
+
+    package My::Ok;
+    use Test2::API qw/context/;
+
+    our @EXPORT = qw/my_ok/;
+    use base 'Exporter';
+
+    # Just like ok() from Test::More
+    sub my_ok($;$) {
+        my ($bool, $name) = @_;
+        my $ctx = context(); # Get a context
+        $ctx->ok($bool, $name);
+        $ctx->release; # Release the context
+        return $bool;
+    }
+
+See L<Test2::API::Context> for a list of methods available on the context object.
+
+=head2 TESTING YOUR TOOLS
+
+The C<intercept { ... }> tool lets you temporarily intercept all events
+generated by the test system:
+
+    use Test2::API qw/intercept/;
+
+    use My::Ok qw/my_ok/;
+
+    my $events = intercept {
+        # These events are not displayed
+        my_ok(1, "pass");
+        my_ok(0, "fail");
+    };
+
+As of version 1.302178 this now returns an arrayref that is also an instance of
+L<Test2::API::InterceptResult>. See the L<Test2::API::InterceptResult>
+documentation for details on how to best use it.
+
+=head2 OTHER API FUNCTIONS
+
+    use Test2::API qw{
+        test2_init_done
+        test2_stack
+        test2_set_is_end
+        test2_get_is_end
+        test2_ipc
+        test2_formatter_set
+        test2_formatter
+        test2_is_testing_done
+    };
+
+    my $init  = test2_init_done();
+    my $stack = test2_stack();
+    my $ipc   = test2_ipc();
+
+    test2_formatter_set($FORMATTER)
+    my $formatter = test2_formatter();
+
+    ... And others ...
+
+=head1 ENVIRONMENT VARIABLES
+
+See L<Test2::Env> for a list of meaningul environment variables.
+
+=head1 MAIN API EXPORTS
+
+All exports are optional. You must specify subs to import.
+
+    use Test2::API qw/context intercept run_subtest/;
+
+This is the list of exports that are most commonly needed. If you are simply
+writing a tool, then this is probably all you need. If you need something and
+you cannot find it here, then you can also look at L</OTHER API EXPORTS>.
+
+These exports lack the 'test2_' prefix because of how important/common they
+are. Exports in the L</OTHER API EXPORTS> section have the 'test2_' prefix to
+ensure they stand out.
+
+=head2 context(...)
+
+Usage:
+
+=over 4
+
+=item $ctx = context()
+
+=item $ctx = context(%params)
+
+=back
+
+The C<context()> function will always return the current context. If
+there is already a context active, it will be returned. If there is not an
+active context, one will be generated. When a context is generated it will
+default to using the file and line number where the currently running sub was
+called from.
+
+Please see L<Test2::API::Context/"CRITICAL DETAILS"> for important rules about
+what you can and cannot do with a context once it is obtained.
+
+B<Note> This function will throw an exception if you ignore the context object
+it returns.
+
+B<Note> On perls 5.14+ a depth check is used to ensure there are no context
+leaks. This cannot be safely done on older perls due to
+L<https://rt.perl.org/Public/Bug/Display.html?id=127774>
+You can forcefully enable it either by setting C<$ENV{T2_CHECK_DEPTH} = 1> or
+C<$Test2::API::DO_DEPTH_CHECK = 1> B<BEFORE> loading L<Test2::API>.
+
+=head3 OPTIONAL PARAMETERS
+
+All parameters to C<context> are optional.
+
+=over 4
+
+=item level => $int
+
+If you must obtain a context in a sub deeper than your entry point you can use
+this to tell it how many EXTRA stack frames to look back. If this option is not
+provided the default of C<0> is used.
+
+    sub third_party_tool {
+        my $sub = shift;
+        ... # Does not obtain a context
+        $sub->();
+        ...
+    }
+
+    third_party_tool(sub {
+        my $ctx = context(level => 1);
+        ...
+        $ctx->release;
+    });
+
+=item wrapped => $int
+
+Use this if you need to write your own tool that wraps a call to C<context()>
+with the intent that it should return a context object.
+
+    sub my_context {
+        my %params = ( wrapped => 0, @_ );
+        $params{wrapped}++;
+        my $ctx = context(%params);
+        ...
+        return $ctx;
+    }
+
+    sub my_tool {
+        my $ctx = my_context();
+        ...
+        $ctx->release;
+    }
+
+If you do not do this, then tools you call that also check for a context will
+notice that the context they grabbed was created at the same stack depth, which
+will trigger protective measures that warn you and destroy the existing
+context.
+
+=item stack => $stack
+
+Normally C<context()> looks at the global hub stack. If you are maintaining
+your own L<Test2::API::Stack> instance you may pass it in to be used
+instead of the global one.
+
+=item hub => $hub
+
+Use this parameter if you want to obtain the context for a specific hub instead
+of whatever one happens to be at the top of the stack.
+
+=item on_init => sub { ... }
+
+This lets you provide a callback sub that will be called B<ONLY> if your call
+to C<context()> generated a new context. The callback B<WILL NOT> be called if
+C<context()> is returning an existing context. The only argument passed into
+the callback will be the context object itself.
+
+    sub foo {
+        my $ctx = context(on_init => sub { 'will run' });
+
+        my $inner = sub {
+            # This callback is not run since we are getting the existing
+            # context from our parent sub.
+            my $ctx = context(on_init => sub { 'will NOT run' });
+            $ctx->release;
+        }
+        $inner->();
+
+        $ctx->release;
+    }
+
+=item on_release => sub { ... }
+
+This lets you provide a callback sub that will be called when the context
+instance is released. This callback will be added to the returned context even
+if an existing context is returned. If multiple calls to context add callbacks,
+then all will be called in reverse order when the context is finally released.
+
+    sub foo {
+        my $ctx = context(on_release => sub { 'will run second' });
+
+        my $inner = sub {
+            my $ctx = context(on_release => sub { 'will run first' });
+
+            # Neither callback runs on this release
+            $ctx->release;
+        }
+        $inner->();
+
+        # Both callbacks run here.
+        $ctx->release;
+    }
+
+=back
+
+=head2 release($;$)
+
+Usage:
+
+=over 4
+
+=item release $ctx;
+
+=item release $ctx, ...;
+
+=back
+
+This is intended as a shortcut that lets you release your context and return a
+value in one statement. This function will get your context, and an optional
+return value. It will release your context, then return your value. Scalar
+context is always assumed.
+
+    sub tool {
+        my $ctx = context();
+        ...
+
+        return release $ctx, 1;
+    }
+
+This tool is most useful when you want to return the value you get from calling
+a function that needs to see the current context:
+
+    my $ctx = context();
+    my $out = some_tool(...);
+    $ctx->release;
+    return $out;
+
+We can combine the last 3 lines of the above like so:
+
+    my $ctx = context();
+    release $ctx, some_tool(...);
+
+=head2 context_do(&;@)
+
+Usage:
+
+    sub my_tool {
+        context_do {
+            my $ctx = shift;
+
+            my (@args) = @_;
+
+            $ctx->ok(1, "pass");
+
+            ...
+
+            # No need to call $ctx->release, done for you on scope exit.
+        } @_;
+    }
+
+Using this inside your test tool takes care of a lot of boilerplate for you. It
+will ensure a context is acquired. It will capture and rethrow any exception. It
+will ensure the context is released when you are done. It preserves the
+subroutine call context (list, scalar, void).
+
+This is the safest way to write a test tool. The only two downsides to this are a
+slight performance decrease, and some extra indentation in your source. If the
+indentation is a problem for you then you can take a peek at the next section.
+
+=head2 no_context(&;$)
+
+Usage:
+
+=over 4
+
+=item no_context { ... };
+
+=item no_context { ... } $hid;
+
+    sub my_tool(&) {
+        my $code = shift;
+        my $ctx = context();
+        ...
+
+        no_context {
+            # Things in here will not see our current context, they get a new
+            # one.
+
+            $code->();
+        };
+
+        ...
+        $ctx->release;
+    };
+
+=back
+
+This tool will hide a context for the provided block of code. This means any
+tools run inside the block will get a completely new context if they acquire
+one. The new context will be inherited by tools nested below the one that
+acquired it.
+
+This will normally hide the current context for the top hub. If you need to
+hide the context for a different hub you can pass in the optional C<$hid>
+parameter.
+
+=head2 intercept(&)
+
+Usage:
+
+    my $events = intercept {
+        ok(1, "pass");
+        ok(0, "fail");
+        ...
+    };
+
+This function takes a codeblock as its only argument, and it has a prototype.
+It will execute the codeblock, intercepting any generated events in the
+process. It will return an array reference with all the generated event
+objects. All events should be subclasses of L<Test2::Event>.
+
+As of version 1.302178 the events array that is returned is blssed as an
+L<Test2::API::InterceptResult> instance. L<Test2::API::InterceptResult>
+Provides a helpful interface for filtering and/or inspecting the events list
+overall, or individual events within the list.
+
+This is intended to help you test your test code. This is not intended for
+people simply writing tests.
+
+=head2 run_subtest(...)
+
+Usage:
+
+    run_subtest($NAME, \&CODE, $BUFFERED, @ARGS)
+
+    # or
+
+    run_subtest($NAME, \&CODE, \%PARAMS, @ARGS)
+
+This will run the provided codeblock with the args in C<@args>. This codeblock
+will be run as a subtest. A subtest is an isolated test state that is condensed
+into a single L<Test2::Event::Subtest> event, which contains all events
+generated inside the subtest.
+
+=head3 ARGUMENTS:
+
+=over 4
+
+=item $NAME
+
+The name of the subtest.
+
+=item \&CODE
+
+The code to run inside the subtest.
+
+=item $BUFFERED or \%PARAMS
+
+If this is a simple scalar then it will be treated as a boolean for the
+'buffered' setting. If this is a hash reference then it will be used as a
+parameters hash. The param hash will be used for hub construction (with the
+specified keys removed).
+
+Keys that are removed and used by run_subtest:
+
+=over 4
+
+=item 'buffered' => $bool
+
+Toggle buffered status.
+
+=item 'inherit_trace' => $bool
+
+Normally the subtest hub is pushed and the sub is allowed to generate its own
+root context for the hub. When this setting is turned on a root context will be
+created for the hub that shares the same trace as the current context.
+
+Set this to true if your tool is producing subtests without user-specified
+subs.
+
+=item 'no_fork' => $bool
+
+Defaults to off. Normally forking inside a subtest will actually fork the
+subtest, resulting in 2 final subtest events. This parameter will turn off that
+behavior, only the original process/thread will return a final subtest event.
+
+=back
+
+=item @ARGS
+
+Any extra arguments you want passed into the subtest code.
+
+=back
+
+=head3 BUFFERED VS UNBUFFERED (OR STREAMED)
+
+Normally all events inside and outside a subtest are sent to the formatter
+immediately by the hub. Sometimes it is desirable to hold off sending events
+within a subtest until the subtest is complete. This usually depends on the
+formatter being used.
+
+=over 4
+
+=item Things not affected by this flag
+
+In both cases events are generated and stored in an array. This array is
+eventually used to populate the C<subevents> attribute on the
+L<Test2::Event::Subtest> event that is generated at the end of the subtest.
+This flag has no effect on this part; it always happens.
+
+At the end of the subtest, the final L<Test2::Event::Subtest> event is sent to
+the formatter.
+
+=item Things that are affected by this flag
+
+The C<buffered> attribute of the L<Test2::Event::Subtest> event will be set to
+the value of this flag. This means any formatter, listener, etc which looks at
+the event will know if it was buffered.
+
+=item Things that are formatter dependent
+
+Events within a buffered subtest may or may not be sent to the formatter as
+they happen. If a formatter fails to specify then the default is to B<NOT SEND>
+the events as they are generated, instead the formatter can pull them from the
+C<subevents> attribute.
+
+A formatter can specify by implementing the C<hide_buffered()> method. If this
+method returns true then events generated inside a buffered subtest will not be
+sent independently of the final subtest event.
+
+=back
+
+An example of how this is used is the L<Test2::Formatter::TAP> formatter. For
+unbuffered subtests the events are rendered as they are generated. At the end
+of the subtest, the final subtest event is rendered, but the C<subevents>
+attribute is ignored. For buffered subtests the opposite occurs, the events are
+NOT rendered as they are generated, instead the C<subevents> attribute is used
+to render them all at once. This is useful when running subtests tests in
+parallel, since without it the output from subtests would be interleaved
+together.
+
+=head1 OTHER API EXPORTS
+
+Exports in this section are not commonly needed. These all have the 'test2_'
+prefix to help ensure they stand out. You should look at the L</MAIN API
+EXPORTS> section before looking here. This section is one where "Great power
+comes with great responsibility". It is possible to break things badly if you
+are not careful with these.
+
+All exports are optional. You need to list which ones you want at import time:
+
+    use Test2::API qw/test2_init_done .../;
+
+=head2 STATUS AND INITIALIZATION STATE
+
+These provide access to internal state and object instances.
+
+=over 4
+
+=item $bool = test2_init_done()
+
+This will return true if the stack and IPC instances have already been
+initialized. It will return false if they have not. Init happens as late as
+possible. It happens as soon as a tool requests the IPC instance, the
+formatter, or the stack.
+
+=item $bool = test2_load_done()
+
+This will simply return the boolean value of the loaded flag. If Test2 has
+finished loading this will be true, otherwise false. Loading is considered
+complete the first time a tool requests a context.
+
+=item test2_set_is_end()
+
+=item test2_set_is_end($bool)
+
+This is used to toggle Test2's belief that the END phase has already started.
+With no arguments this will set it to true. With arguments it will set it to
+the first argument's value.
+
+This is used to prevent the use of C<caller()> in END blocks which can cause
+segfaults. This is only necessary in some persistent environments that may have
+multiple END phases.
+
+=item $bool = test2_get_is_end()
+
+Check if Test2 believes it is the END phase.
+
+=item $stack = test2_stack()
+
+This will return the global L<Test2::API::Stack> instance. If this has not
+yet been initialized it will be initialized now.
+
+=item $bool = test2_is_testing_done()
+
+This will return true if testing is complete and no other events should be
+sent. This is useful in things like warning handlers where you might want to
+turn warnings into events, but need them to start acting like normal warnings
+when testing is done.
+
+    $SIG{__WARN__} = sub {
+        my ($warning) = @_;
+
+        if (test2_is_testing_done()) {
+            warn @_;
+        }
+        else {
+            my $ctx = context();
+            ...
+            $ctx->release
+        }
+    }
+
+=item test2_ipc_disable
+
+Disable IPC.
+
+=item $bool = test2_ipc_disabled
+
+Check if IPC is disabled.
+
+=item test2_ipc_wait_enable()
+
+=item test2_ipc_wait_disable()
+
+=item $bool = test2_ipc_wait_enabled()
+
+These can be used to turn IPC waiting on and off, or check the current value of
+the flag.
+
+Waiting is turned on by default. Waiting will cause the parent process/thread
+to wait until all child processes and threads are finished before exiting. You
+will almost never want to turn this off.
+
+=item $bool = test2_no_wait()
+
+=item test2_no_wait($bool)
+
+B<DISCOURAGED>: This is a confusing interface, it is better to use
+C<test2_ipc_wait_enable()>, C<test2_ipc_wait_disable()> and
+C<test2_ipc_wait_enabled()>.
+
+This can be used to get/set the no_wait status. Waiting is turned on by
+default. Waiting will cause the parent process/thread to wait until all child
+processes and threads are finished before exiting. You will almost never want
+to turn this off.
+
+=item $fh = test2_stdout()
+
+=item $fh = test2_stderr()
+
+These functions return the filehandles that test output should be written to.
+They are primarily useful when writing a custom formatter and code that turns
+events into actual output (TAP, etc.).  They will return a dupe of the original
+filehandles that formatted output can be sent to regardless of whatever state
+the currently running test may have left STDOUT and STDERR in.
+
+=item test2_reset_io()
+
+Re-dupe the internal filehandles returned by C<test2_stdout()> and
+C<test2_stderr()> from the current STDOUT and STDERR.  You shouldn't need to do
+this except in very peculiar situations (for example, you're testing a new
+formatter and you need control over where the formatter is sending its output.)
+
+=back
+
+=head2 BEHAVIOR HOOKS
+
+These are hooks that allow you to add custom behavior to actions taken by Test2
+and tools built on top of it.
+
+=over 4
+
+=item test2_add_callback_exit(sub { ... })
+
+This can be used to add a callback that is called after all testing is done. This
+is too late to add additional results, the main use of this callback is to set the
+exit code.
+
+    test2_add_callback_exit(
+        sub {
+            my ($context, $exit, \$new_exit) = @_;
+            ...
+        }
+    );
+
+The C<$context> passed in will be an instance of L<Test2::API::Context>. The
+C<$exit> argument will be the original exit code before anything modified it.
+C<$$new_exit> is a reference to the new exit code. You may modify this to
+change the exit code. Please note that C<$$new_exit> may already be different
+from C<$exit>
+
+=item test2_add_callback_post_load(sub { ... })
+
+Add a callback that will be called when Test2 is finished loading. This
+means the callback will be run once, the first time a context is obtained.
+If Test2 has already finished loading then the callback will be run immediately.
+
+=item test2_add_callback_testing_done(sub { ... })
+
+This adds your coderef as a follow-up to the root hub after Test2 is finished loading.
+
+This is essentially a helper to do the following:
+
+    test2_add_callback_post_load(sub {
+        my $stack = test2_stack();
+        $stack->top; # Ensure we have a hub
+        my ($hub) = Test2::API::test2_stack->all;
+
+        $hub->set_active(1);
+
+        $hub->follow_up(sub { ... }); # <-- Your coderef here
+    });
+
+=item test2_add_callback_context_acquire(sub { ... })
+
+Add a callback that will be called every time someone tries to acquire a
+context. This will be called on EVERY call to C<context()>. It gets a single
+argument, a reference to the hash of parameters being used the construct the
+context. This is your chance to change the parameters by directly altering the
+hash.
+
+    test2_add_callback_context_acquire(sub {
+        my $params = shift;
+        $params->{level}++;
+    });
+
+This is a very scary API function. Please do not use this unless you need to.
+This is here for L<Test::Builder> and backwards compatibility. This has you
+directly manipulate the hash instead of returning a new one for performance
+reasons.
+
+=item test2_add_callback_context_init(sub { ... })
+
+Add a callback that will be called every time a new context is created. The
+callback will receive the newly created context as its only argument.
+
+=item test2_add_callback_context_release(sub { ... })
+
+Add a callback that will be called every time a context is released. The
+callback will receive the released context as its only argument.
+
+=item test2_add_callback_pre_subtest(sub { ... })
+
+Add a callback that will be called every time a subtest is going to be
+run. The callback will receive the subtest name, coderef, and any
+arguments.
+
+=item @list = test2_list_context_acquire_callbacks()
+
+Return all the context acquire callback references.
+
+=item @list = test2_list_context_init_callbacks()
+
+Returns all the context init callback references.
+
+=item @list = test2_list_context_release_callbacks()
+
+Returns all the context release callback references.
+
+=item @list = test2_list_exit_callbacks()
+
+Returns all the exit callback references.
+
+=item @list = test2_list_post_load_callbacks()
+
+Returns all the post load callback references.
+
+=item @list = test2_list_pre_subtest_callbacks()
+
+Returns all the pre-subtest callback references.
+
+=item test2_add_uuid_via(sub { ... })
+
+=item $sub = test2_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.
+
+=item test2_add_pending_diag($diag)
+
+=item test2_add_pending_diag($diag1, $diag2)
+
+Add a diagnostics message that will be issued the next time a context in which
+a failure occured is released.
+
+This can also be thought of like this: "If the next bit causes a failed
+assertion, add this diagnostics message".
+
+=item @diags = test2_get_pending_diags()
+
+Get all the current pending diagnostics messages.
+
+=item @diags = test2_clear_pending_diags()
+
+Clear any pending diagnostics, returning them.
+
+=back
+
+=head2 IPC AND CONCURRENCY
+
+These let you access, or specify, the IPC system internals.
+
+=over 4
+
+=item $bool = test2_has_ipc()
+
+Check if IPC is enabled.
+
+=item $ipc = test2_ipc()
+
+This will return the global L<Test2::IPC::Driver> instance. If this has not yet
+been initialized it will be initialized now.
+
+=item test2_ipc_add_driver($DRIVER)
+
+Add an IPC driver to the list. This will add the driver to the start of the
+list.
+
+=item @drivers = test2_ipc_drivers()
+
+Get the list of IPC drivers.
+
+=item $bool = test2_ipc_polling()
+
+Check if polling is enabled.
+
+=item test2_ipc_enable_polling()
+
+Turn on polling. This will cull events from other processes and threads every
+time a context is created.
+
+=item test2_ipc_disable_polling()
+
+Turn off IPC polling.
+
+=item test2_ipc_enable_shm()
+
+Legacy, this is currently a no-op that returns 0;
+
+=item test2_ipc_set_pending($uniq_val)
+
+Tell other processes and events that an event is pending. C<$uniq_val> should
+be a unique value no other thread/process will generate.
+
+B<Note:> After calling this C<test2_ipc_get_pending()> will return 1. This is
+intentional, and not avoidable.
+
+=item $pending = test2_ipc_get_pending()
+
+This returns -1 if there is no way to check (assume yes)
+
+This returns 0 if there are (most likely) no pending events.
+
+This returns 1 if there are (likely) pending events. Upon return it will reset,
+nothing else will be able to see that there were pending events.
+
+=item $timeout = test2_ipc_get_timeout()
+
+=item test2_ipc_set_timeout($timeout)
+
+Get/Set the timeout value for the IPC system. This timeout is how long the IPC
+system will wait for child processes and threads to finish before aborting.
+
+The default value is C<30> seconds.
+
+=back
+
+=head2 MANAGING FORMATTERS
+
+These let you access, or specify, the formatters that can/should be used.
+
+=over 4
+
+=item $formatter = test2_formatter
+
+This will return the global formatter class. This is not an instance. By
+default the formatter is set to L<Test2::Formatter::TAP>.
+
+You can override this default using the C<T2_FORMATTER> environment variable.
+
+Normally 'Test2::Formatter::' is prefixed to the value in the
+environment variable:
+
+    $ T2_FORMATTER='TAP' perl test.t     # Use the Test2::Formatter::TAP formatter
+    $ T2_FORMATTER='Foo' perl test.t     # Use the Test2::Formatter::Foo formatter
+
+If you want to specify a full module name you use the '+' prefix:
+
+    $ T2_FORMATTER='+Foo::Bar' perl test.t     # Use the Foo::Bar formatter
+
+=item test2_formatter_set($class_or_instance)
+
+Set the global formatter class. This can only be set once. B<Note:> This will
+override anything specified in the 'T2_FORMATTER' environment variable.
+
+=item @formatters = test2_formatters()
+
+Get a list of all loaded formatters.
+
+=item test2_formatter_add($class_or_instance)
+
+Add a formatter to the list. Last formatter added is used at initialization. If
+this is called after initialization a warning will be issued.
+
+=back
+
+=head2 TIME STAMPS
+
+You can enable or disable timestamps in trace facets. They are disabled by
+default for compatibility and performance reasons.
+
+=over 4
+
+=item test2_enable_trace_stamps()
+
+Enable stamps in traces.
+
+=item test2_disable_trace_stamps()
+
+Disable stamps in traces.
+
+=item $bool = test2_trace_stamps_enabled()
+
+Check status of trace stamps.
+
+=back
+
+=head1 OTHER EXAMPLES
+
+See the C</Examples/> directory included in this distribution.
+
+=head1 SEE ALSO
+
+L<Test2::API::Context> - Detailed documentation of the context object.
+
+L<Test2::IPC> - The IPC system used for threading/fork support.
+
+L<Test2::Formatter> - Formatters such as TAP live here.
+
+L<Test2::Event> - Events live in this namespace.
+
+L<Test2::Hub> - All events eventually funnel through a hub. Custom hubs are how
+C<intercept()> and C<run_subtest()> are implemented.
+
+=head1 MAGIC
+
+This package has an END block. This END block is responsible for setting the
+exit code based on the test results. This end block also calls the callbacks that
+can be added to this package.
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/AsyncSubtest.pm

@@ -0,0 +1,823 @@
+package Test2::AsyncSubtest;
+use strict;
+use warnings;
+
+use Test2::IPC;
+
+our $VERSION = '1.302210';
+
+our @CARP_NOT = qw/Test2::Util::HashBase/;
+
+use Carp qw/croak cluck confess/;
+use Test2::Util qw/get_tid CAN_THREAD CAN_FORK/;
+use Scalar::Util qw/blessed weaken/;
+use List::Util qw/first/;
+
+use Test2::API();
+use Test2::API::Context();
+use Test2::Util::Trace();
+use Test2::Util::Guard();
+use Time::HiRes();
+
+use Test2::AsyncSubtest::Hub();
+use Test2::AsyncSubtest::Event::Attach();
+use Test2::AsyncSubtest::Event::Detach();
+
+use Test2::Util::HashBase qw{
+    name hub
+    trace frame send_to
+    events
+    finished
+    active
+    stack
+    id cid uuid
+    children
+    _in_use
+    _attached pid tid
+    start_stamp stop_stamp
+};
+
+sub CAN_REALLY_THREAD {
+    return 0 unless CAN_THREAD;
+    return 0 unless eval { require threads; threads->VERSION('1.34'); 1 };
+    return 1;
+}
+
+
+my $UUID_VIA = Test2::API::_add_uuid_via_ref();
+my $CID = 1;
+my @STACK;
+
+sub TOP { @STACK ? $STACK[-1] : undef }
+
+sub init {
+    my $self = shift;
+
+    croak "'name' is a required attribute"
+        unless $self->{+NAME};
+
+    my $to = $self->{+SEND_TO} ||= Test2::API::test2_stack()->top;
+
+    $self->{+STACK} = [@STACK];
+    $_->{+_IN_USE}++ for reverse @STACK;
+
+    $self->{+TID}       = get_tid;
+    $self->{+PID}       = $$;
+    $self->{+CID}       = 'AsyncSubtest-' . $CID++;
+    $self->{+ID}        = 1;
+    $self->{+FINISHED}  = 0;
+    $self->{+ACTIVE}    = 0;
+    $self->{+_IN_USE}   = 0;
+    $self->{+CHILDREN}  = [];
+    $self->{+UUID} = ${$UUID_VIA}->() if defined $$UUID_VIA;
+
+    unless($self->{+HUB}) {
+        my $ipc = Test2::API::test2_ipc();
+        my $formatter = Test2::API::test2_stack->top->format;
+        my $args = delete $self->{hub_init_args} || {};
+        my $hub = Test2::AsyncSubtest::Hub->new(
+            %$args,
+            ipc       => $ipc,
+            nested    => $to->nested + 1,
+            buffered  => 1,
+            formatter => $formatter,
+        );
+        weaken($hub->{ast} = $self);
+        $self->{+HUB} = $hub;
+    }
+
+    $self->{+TRACE} ||= Test2::Util::Trace->new(
+        frame    => $self->{+FRAME} || [caller(1)],
+        buffered => $to->buffered,
+        nested   => $to->nested,
+        cid      => $self->{+CID},
+        uuid     => $self->{+UUID},
+        hid      => $to->hid,
+        huuid    => $to->uuid,
+    );
+
+    my $hub = $self->{+HUB};
+    $hub->set_ast_ids({}) unless $hub->ast_ids;
+    $hub->listen($self->_listener);
+}
+
+sub _listener {
+    my $self = shift;
+
+    my $events = $self->{+EVENTS} ||= [];
+
+    sub { push @$events => $_[1] };
+}
+
+sub context {
+    my $self = shift;
+
+    my $send_to = $self->{+SEND_TO};
+
+    confess "Attempt to close AsyncSubtest when original parent hub (a non async-subtest?) has ended"
+        if $send_to->ended;
+
+    return Test2::API::Context->new(
+        trace => $self->{+TRACE},
+        hub   => $send_to,
+    );
+}
+
+sub _gen_event {
+    my $self = shift;
+    my ($type, $id, $hub) = @_;
+
+    my $class = "Test2::AsyncSubtest::Event::$type";
+
+    return $class->new(
+        id    => $id,
+        trace => Test2::Util::Trace->new(
+            frame    => [caller(1)],
+            buffered => $hub->buffered,
+            nested   => $hub->nested,
+            cid      => $self->{+CID},
+            uuid     => $self->{+UUID},
+            hid      => $hub->hid,
+            huuid    => $hub->uuid,
+        ),
+    );
+}
+
+sub cleave {
+    my $self = shift;
+    my $id = $self->{+ID}++;
+    $self->{+HUB}->ast_ids->{$id} = 0;
+    return $id;
+}
+
+sub attach {
+    my $self = shift;
+    my ($id) = @_;
+
+    croak "An ID is required" unless $id;
+
+    croak "ID $id is not valid"
+        unless defined $self->{+HUB}->ast_ids->{$id};
+
+    croak "ID $id is already attached"
+        if $self->{+HUB}->ast_ids->{$id};
+
+    croak "You must attach INSIDE the child process/thread"
+        if $self->{+HUB}->is_local;
+
+    $self->{+_ATTACHED} = [ $$, get_tid, $id ];
+    $self->{+HUB}->send($self->_gen_event('Attach', $id, $self->{+HUB}));
+}
+
+sub detach {
+    my $self = shift;
+
+    if ($self->{+PID} == $$ && $self->{+TID} == get_tid) {
+        cluck "You must detach INSIDE the child process/thread ($$, " . get_tid . " instead of $self->{+PID}, $self->{+TID})";
+        return;
+    }
+
+    my $att = $self->{+_ATTACHED}
+        or croak "Not attached";
+
+    croak "Attempt to detach from wrong child"
+        unless $att->[0] == $$ && $att->[1] == get_tid;
+
+    my $id = $att->[2];
+
+    $self->{+HUB}->send($self->_gen_event('Detach', $id, $self->{+HUB}));
+
+    delete $self->{+_ATTACHED};
+}
+
+sub ready { return !shift->pending }
+sub pending {
+    my $self = shift;
+    my $hub = $self->{+HUB};
+    return -1 unless $hub->is_local;
+
+    $hub->cull;
+
+    return $self->{+_IN_USE} + keys %{$self->{+HUB}->ast_ids};
+}
+
+sub run {
+    my $self = shift;
+    my ($code, @args) = @_;
+
+    croak "AsyncSubtest->run() takes a codeblock as the first argument"
+        unless $code && ref($code) eq 'CODE';
+
+    $self->start;
+
+    my ($ok, $err, $finished);
+    T2_SUBTEST_WRAPPER: {
+        $ok = eval { $code->(@args); 1 };
+        $err = $@;
+
+        # They might have done 'BEGIN { skip_all => "whatever" }'
+        if (!$ok && $err =~ m/Label not found for "last T2_SUBTEST_WRAPPER"/) {
+            $ok  = undef;
+            $err = undef;
+        }
+        else {
+            $finished = 1;
+        }
+    }
+
+    $self->stop;
+
+    my $hub = $self->{+HUB};
+
+    if (!$finished) {
+        if(my $bailed = $hub->bailed_out) {
+            my $ctx = $self->context;
+            $ctx->bail($bailed->reason);
+            return;
+        }
+        my $code = $hub->exit_code;
+        $ok = !$code;
+        $err = "Subtest ended with exit code $code" if $code;
+    }
+
+    unless ($ok) {
+        my $e = Test2::Event::Exception->new(
+            error => $err,
+            trace => Test2::Util::Trace->new(
+                frame    => [caller(0)],
+                buffered => $hub->buffered,
+                nested   => $hub->nested,
+                cid      => $self->{+CID},
+                uuid     => $self->{+UUID},
+                hid      => $hub->hid,
+                huuid    => $hub->uuid,
+            ),
+        );
+        $hub->send($e);
+    }
+
+    return $hub->is_passing;
+}
+
+sub start {
+    my $self = shift;
+
+    croak "Subtest is already complete"
+        if $self->{+FINISHED};
+
+    $self->{+START_STAMP} = Time::HiRes::time() unless defined $self->{+START_STAMP};
+
+    $self->{+ACTIVE}++;
+
+    push @STACK => $self;
+    my $hub = $self->{+HUB};
+    my $stack = Test2::API::test2_stack();
+    $stack->push($hub);
+
+    return $hub->is_passing;
+}
+
+sub stop {
+    my $self = shift;
+
+    croak "Subtest is not active"
+        unless $self->{+ACTIVE}--;
+
+    croak "AsyncSubtest stack mismatch"
+        unless @STACK && $self == $STACK[-1];
+
+    $self->{+STOP_STAMP} = Time::HiRes::time();
+
+    pop @STACK;
+
+    my $hub = $self->{+HUB};
+    my $stack = Test2::API::test2_stack();
+    $stack->pop($hub);
+    return $hub->is_passing;
+}
+
+sub finish {
+    my $self = shift;
+    my %params = @_;
+
+    my $hub = $self->hub;
+
+    croak "Subtest is already finished"
+        if $self->{+FINISHED}++;
+
+    croak "Subtest can only be finished in the process/thread that created it"
+        unless $hub->is_local;
+
+    croak "Subtest is still active"
+        if $self->{+ACTIVE};
+
+    $self->wait;
+    $self->{+STOP_STAMP} = Time::HiRes::time() unless defined $self->{+STOP_STAMP};
+    my $stop_stamp = $self->{+STOP_STAMP};
+
+    my $todo       = $params{todo};
+    my $skip       = $params{skip};
+    my $empty      = !@{$self->{+EVENTS}};
+    my $no_asserts = !$hub->count;
+    my $collapse   = $params{collapse};
+    my $no_plan    = $params{no_plan} || ($collapse && $no_asserts) || $skip;
+
+    my $trace = Test2::Util::Trace->new(
+        frame    => $self->{+TRACE}->{frame},
+        buffered => $hub->buffered,
+        nested   => $hub->nested,
+        cid      => $self->{+CID},
+        uuid     => $self->{+UUID},
+        hid      => $hub->hid,
+        huuid    => $hub->uuid,
+    );
+
+    $hub->finalize($trace, !$no_plan)
+        unless $hub->no_ending || $hub->ended;
+
+    if ($hub->ipc) {
+        $hub->ipc->drop_hub($hub->hid);
+        $hub->set_ipc(undef);
+    }
+
+    return $hub->is_passing if $params{silent};
+
+    my $ctx = $self->context;
+
+    my $pass = 1;
+    if ($skip) {
+        $ctx->skip($self->{+NAME}, $skip);
+    }
+    else {
+        if ($collapse && $empty) {
+            $ctx->ok($hub->is_passing, $self->{+NAME});
+            return $hub->is_passing;
+        }
+
+        if ($collapse && $no_asserts) {
+            push @{$self->{+EVENTS}} => Test2::Event::Plan->new(trace => $trace, max => 0, directive => 'SKIP', reason => "No assertions");
+        }
+
+        my $e = $ctx->build_event(
+            'Subtest',
+            pass         => $hub->is_passing,
+            subtest_id   => $hub->id,
+            subtest_uuid => $hub->uuid,
+            name         => $self->{+NAME},
+            buffered     => 1,
+            subevents    => $self->{+EVENTS},
+            start_stamp  => $self->{+START_STAMP},
+            stop_stamp   => $self->{+STOP_STAMP},
+            $todo ? (
+                todo => $todo,
+                effective_pass => 1,
+            ) : (),
+        );
+
+        $ctx->hub->send($e);
+
+        unless ($e->effective_pass) {
+            $ctx->failure_diag($e);
+
+            $ctx->diag("Bad subtest plan, expected " . $hub->plan . " but ran " . $hub->count)
+                if $hub->plan && !$hub->check_plan && !grep {$_->causes_fail} @{$self->{+EVENTS}};
+        }
+
+        $pass = $e->pass;
+    }
+
+    $_->{+_IN_USE}-- for reverse @{$self->{+STACK}};
+
+    return $pass;
+}
+
+sub wait {
+    my $self = shift;
+
+    my $hub = $self->{+HUB};
+    my $children = $self->{+CHILDREN};
+
+    while (@$children) {
+        $hub->cull;
+        if (my $child = pop @$children) {
+            if (blessed($child)) {
+                $child->join;
+            }
+            else {
+                waitpid($child, 0);
+            }
+        }
+        else {
+            Time::HiRes::sleep('0.01');
+        }
+    }
+
+    $hub->cull;
+
+    cluck "Subtest '$self->{+NAME}': All children have completed, but we still appear to be pending"
+        if $hub->is_local && keys %{$self->{+HUB}->ast_ids};
+}
+
+sub fork {
+    croak "Forking is not supported" unless CAN_FORK;
+    my $self = shift;
+    my $id = $self->cleave;
+    my $pid = CORE::fork();
+
+    unless (defined $pid) {
+        delete $self->{+HUB}->ast_ids->{$id};
+        croak "Failed to fork";
+    }
+
+    if($pid) {
+        push @{$self->{+CHILDREN}} => $pid;
+        return $pid;
+    }
+
+    $self->attach($id);
+
+    return $self->_guard;
+}
+
+sub run_fork {
+    my $self = shift;
+    my ($code, @args) = @_;
+
+    my $f = $self->fork;
+    return $f unless blessed($f);
+
+    $self->run($code, @args);
+
+    $self->detach();
+    $f->dismiss();
+    exit 0;
+}
+
+sub run_thread {
+    croak "Threading is not supported"
+        unless CAN_REALLY_THREAD;
+
+    my $self = shift;
+    my ($code, @args) = @_;
+
+    my $id = $self->cleave;
+    my $thr =  threads->create(sub {
+        $self->attach($id);
+
+        $self->run($code, @args);
+
+        $self->detach(get_tid);
+        return 0;
+    });
+
+    push @{$self->{+CHILDREN}} => $thr;
+
+    return $thr;
+}
+
+sub _guard {
+    my $self = shift;
+
+    my ($pid, $tid) = ($$, get_tid);
+
+    return Test2::Util::Guard->new(sub {
+        return unless $$ == $pid && get_tid == $tid;
+
+        my $error = "Scope Leak";
+        if (my $ex = $@) {
+            chomp($ex);
+            $error .= " ($ex)";
+        }
+
+        cluck $error;
+
+        my $e = $self->context->build_event(
+            'Exception',
+            error => "$error\n",
+        );
+        $self->{+HUB}->send($e);
+        $self->detach();
+        exit 255;
+    });
+}
+
+sub DESTROY {
+    my $self = shift;
+    return unless $self->{+NAME};
+
+    if (my $att = $self->{+_ATTACHED}) {
+        return unless $self->{+HUB};
+        eval { $self->detach() };
+    }
+
+    return if $self->{+FINISHED};
+    return unless $self->{+PID} == $$;
+    return unless $self->{+TID} == get_tid;
+
+    local $@;
+    eval { $_->{+_IN_USE}-- for reverse @{$self->{+STACK}} };
+
+    warn "Subtest $self->{+NAME} did not finish!";
+    exit 255;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::AsyncSubtest - Object representing an async subtest.
+
+=head1 DESCRIPTION
+
+Regular subtests have a limited scope, they start, events are generated, then
+they close and send an L<Test2::Event::Subtest> event. This is a problem if you
+want the subtest to keep receiving events while other events are also being
+generated. This class implements subtests that stay open until you decide to
+close them.
+
+This is mainly useful for tools that start a subtest in one process and then
+spawn children. In many cases it is nice to let the parent process continue
+instead of waiting on the children.
+
+=head1 SYNOPSIS
+
+    use Test2::AsyncSubtest;
+
+    my $ast = Test2::AsyncSubtest->new(name => foo);
+
+    $ast->run(sub {
+        ok(1, "Event in parent" );
+    });
+
+    ok(1, "Event outside of subtest");
+
+    $ast->run_fork(sub {
+        ok(1, "Event in child process");
+    });
+
+    ...
+
+    $ast->finish;
+
+    done_testing;
+
+=head1 CONSTRUCTION
+
+    my $ast = Test2::AsyncSubtest->new( ... );
+
+=over 4
+
+=item name => $name (required)
+
+Name of the subtest. This construction argument is required.
+
+=item send_to => $hub (optional)
+
+Hub to which the final subtest event should be sent. This must be an instance
+of L<Test2::Hub> or a subclass. If none is specified then the current top hub
+will be used.
+
+=item trace => $trace (optional)
+
+File/Line to which errors should be attributed. This must be an instance of
+L<Test2::Util::Trace>. If none is specified then the file/line where the
+constructor was called will be used.
+
+=item hub => $hub (optional)
+
+Use this to specify a hub the subtest should use. By default a new hub is
+generated. This must be an instance of L<Test2::AsyncSubtest::Hub>.
+
+=back
+
+=head1 METHODS
+
+=head2 SIMPLE ACCESSORS
+
+=over 4
+
+=item $bool = $ast->active
+
+True if the subtest is active. The subtest is active if its hub appears in the
+global hub stack. This is true when C<< $ast->run(...) >> us running.
+
+=item $arrayref = $ast->children
+
+Get an arrayref of child processes/threads. Numerical items are PIDs, blessed
+items are L<threads> instances.
+
+=item $arrayref = $ast->events
+
+Get an arrayref of events that have been sent to the subtests hub.
+
+=item $bool = $ast->finished
+
+True if C<finished()> has already been called.
+
+=item $hub = $ast->hub
+
+The hub created for the subtest.
+
+=item $int = $ast->id
+
+Attach/Detach counter. Used internally, not useful to users.
+
+=item $str = $ast->name
+
+Name of the subtest.
+
+=item $pid = $ast->pid
+
+PID in which the subtest was created.
+
+=item $tid = $ast->tid
+
+Thread ID in which the subtest was created.
+
+=item $hub = $ast->send_to
+
+Hub to which the final subtest event should be sent.
+
+=item $arrayref = $ast->stack
+
+Stack of async subtests at the time this one was created. This is mainly for
+internal use.
+
+=item $trace = $ast->trace
+
+L<Test2::Util::Trace> instance used for error reporting.
+
+=back
+
+=head2 INTERFACE
+
+=over 4
+
+=item $ast->attach($id)
+
+Attach a subtest in a child/process to the original.
+
+B<Note:> C<< my $id = $ast->cleave >> must have been called in the parent
+process/thread before the child was started, the id it returns must be used in
+the call to C<< $ast->attach($id) >>
+
+=item $id = $ast->cleave
+
+Prepare a slot for a child process/thread to attach. This must be called BEFORE
+the child process or thread is started. The ID returned is used by C<attach()>.
+
+This must only be called in the original process/thread.
+
+=item $ctx = $ast->context
+
+Get an L<Test2::API::Context> instance that can be used to send events to the
+context in which the hub was created. This is not a canonical context, you
+should not call C<< $ctx->release >> on it.
+
+=item $ast->detach
+
+Detach from the parent in a child process/thread. This should be called just
+before the child exits.
+
+=item $ast->finish
+
+=item $ast->finish(%options)
+
+Finish the subtest, wait on children, and send the final subtest event.
+
+This must only be called in the original process/thread.
+
+B<Note:> This calls C<< $ast->wait >>.
+
+These are the options:
+
+=over 4
+
+=item collapse => 1
+
+This intelligently allows a subtest to be empty.
+
+If no events bump the test count then the subtest no final plan will be added.
+The subtest will not be considered a failure (normally an empty subtest is a
+failure).
+
+If there are no events at all the subtest will be collapsed into an
+L<Test2::Event::Ok> event.
+
+=item silent => 1
+
+This will prevent finish from generating a final L<Test2::Event::Subtest>
+event. This effectively ends the subtest without it affecting the parent
+subtest (or top level test).
+
+=item no_plan => 1
+
+This will prevent a final plan from being added to the subtest for you when
+none is directly specified.
+
+=item skip => "reason"
+
+This will issue an L<Test2::Event::Skip> instead of a subtest. This will throw
+an exception if any events have been seen, or if state implies events have
+occurred.
+
+=back
+
+=item $out = $ast->fork
+
+This is a slightly higher level interface to fork. Running it will fork your
+code in-place just like C<fork()>. It will return a pid in the parent, and an
+L<Test2::Util::Guard> instance in the child. An exception will be thrown if
+fork fails.
+
+It is recommended that you use C<< $ast->run_fork(sub { ... }) >> instead.
+
+=item $bool = $ast->pending
+
+True if there are child processes, threads, or subtests that depend on this
+one.
+
+=item $bool = $ast->ready
+
+This is essentially C<< !$ast->pending >>.
+
+=item $ast->run(sub { ... })
+
+Run the provided codeblock inside the subtest. This will push the subtest hub
+onto the stack, run the code, then pop the hub off the stack.
+
+=item $pid = $ast->run_fork(sub { ... })
+
+Same as C<< $ast->run() >>, except that the codeblock is run in a child
+process.
+
+You do not need to directly call C<wait($pid)>, that will be done for you when
+C<< $ast->wait >>, or C<< $ast->finish >> are called.
+
+=item my $thr = $ast->run_thread(sub { ... });
+
+B<** DISCOURAGED **> Threads cause problems. This method remains for anyone who
+REALLY wants it, but it is no longer supported. Tests for this functionality do
+not even run unless the AUTHOR_TESTING or T2_DO_THREAD_TESTS env vars are
+enabled.
+
+Same as C<< $ast->run() >>, except that the codeblock is run in a child
+thread.
+
+You do not need to directly call C<< $thr->join >>, that is done for you when
+C<< $ast->wait >>, or C<< $ast->finish >> are called.
+
+=item $passing = $ast->start
+
+Push the subtest hub onto the stack. Returns the current pass/fail status of
+the subtest.
+
+=item $ast->stop
+
+Pop the subtest hub off the stack. Returns the current pass/fail status of the
+subtest.
+
+=item $ast->wait
+
+Wait on all threads/processes that were started using C<< $ast->fork >>,
+C<< $ast->run_fork >>, or C<< $ast->run_thread >>.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2-AsyncSubtest can be found at
+F<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist7@gmail.comE<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

git/usr/share/perl5/core_perl/Test2/Bundle.pm

@@ -0,0 +1,87 @@
+package Test2::Bundle;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Bundle - Documentation for bundles.
+
+=head1 DESCRIPTION
+
+Bundles are collections of Tools and Plugins. Bundles should not provide any
+tools or behaviors of their own, they should simply combine the tools and
+behaviors of other packages.
+
+=head1 FAQ
+
+=over 4
+
+=item Should my bundle subclass Test2::Bundle?
+
+No. Currently this class is empty. Eventually we may want to add behavior, in
+which case we do not want anyone to already be subclassing it.
+
+=back
+
+=head1 HOW DO I WRITE A BUNDLE?
+
+Writing a bundle can be very simple:
+
+    package Test2::Bundle::MyBundle;
+    use strict;
+    use warnings;
+
+    use Test2::Plugin::ExitSummary; # Load a plugin
+
+    use Test2::Tools::Basic qw/ok plan done_testing/;
+
+    # Re-export the tools
+    our @EXPORTS = qw/ok plan done_testing/;
+    use base 'Exporter';
+
+    1;
+
+If you want to do anything more complex you should look into L<Import::Into>
+and L<Symbol::Move>.
+
+=head1 SOURCE
+
+The source code repository for Test2-Suite can be found at
+F<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/Compare.pm

@@ -0,0 +1,449 @@
+package Test2::Compare;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+use Scalar::Util qw/blessed/;
+use Test2::Util qw/try/;
+use Test2::Util::Ref qw/rtype/;
+
+use Carp qw/croak/;
+
+our @EXPORT_OK = qw{
+    compare
+    get_build push_build pop_build build
+    strict_convert relaxed_convert convert
+};
+use base 'Exporter';
+
+sub compare {
+    my ($got, $check, $convert) = @_;
+
+    $check = $convert->($check);
+
+    return $check->run(
+        id      => undef,
+        got     => $got,
+        exists  => 1,
+        convert => $convert,
+        seen    => {},
+    );
+}
+
+my @BUILD;
+
+sub get_build  { @BUILD ? $BUILD[-1] : undef }
+sub push_build { push @BUILD => $_[0] }
+
+sub pop_build {
+    return pop @BUILD if @BUILD && $_[0] && $BUILD[-1] == $_[0];
+    my $have = @BUILD ? "$BUILD[-1]" : 'undef';
+    my $want = $_[0]  ? "$_[0]"      : 'undef';
+    croak "INTERNAL ERROR: Attempted to pop incorrect build, have $have, tried to pop $want";
+}
+
+sub build {
+    my ($class, $code) = @_;
+
+    my @caller = caller(1);
+
+    die "'$caller[3]\()' should not be called in void context in $caller[1] line $caller[2]\n"
+        unless defined(wantarray);
+
+    my $build = $class->new(builder => $code, called => \@caller);
+
+    push @BUILD => $build;
+    my ($ok, $err) = try { $code->($build); 1 };
+    pop @BUILD;
+    die $err unless $ok;
+
+    return $build;
+}
+
+sub strict_convert  { convert($_[0], { implicit_end => 1, use_regex => 0, use_code => 0 }) }
+sub relaxed_convert { convert($_[0], { implicit_end => 0, use_regex => 1, use_code => 1 }) }
+
+my $CONVERT_LOADED = 0;
+my %ALLOWED_KEYS = ( implicit_end => 1, use_regex => 1, use_code => 1 );
+sub convert {
+    my ($thing, $config) = @_;
+
+    unless($CONVERT_LOADED) {
+        require Test2::Compare::Array;
+        require Test2::Compare::Base;
+        require Test2::Compare::Custom;
+        require Test2::Compare::DeepRef;
+        require Test2::Compare::Hash;
+        require Test2::Compare::Pattern;
+        require Test2::Compare::Ref;
+        require Test2::Compare::Regex;
+        require Test2::Compare::Scalar;
+        require Test2::Compare::String;
+        require Test2::Compare::Undef;
+        require Test2::Compare::Wildcard;
+        $CONVERT_LOADED = 1;
+    }
+
+    if (ref($config)) {
+        my $bad = join ', ' => grep { !$ALLOWED_KEYS{$_} } keys %$config;
+        croak "The following config options are not understood by convert(): $bad" if $bad;
+        $config->{implicit_end} = 1 unless defined $config->{implicit_end};
+        $config->{use_regex}    = 1 unless defined $config->{use_regex};
+        $config->{use_code}     = 0 unless defined $config->{use_code};
+    }
+    else { # Legacy...
+        if ($config) {
+            $config = {
+                implicit_end => 1,
+                use_regex  => 0,
+                use_code   => 0,
+            };
+        }
+        else {
+            $config = {
+                implicit_end => 0,
+                use_regex  => 1,
+                use_code   => 1,
+            };
+        }
+    }
+
+    return _convert($thing, $config);
+}
+
+sub _convert {
+    my ($thing, $config) = @_;
+
+    return Test2::Compare::Undef->new()
+        unless defined $thing;
+
+    if (blessed($thing) && $thing->isa('Test2::Compare::Base')) {
+        if ($config->{implicit_end} && $thing->can('set_ending') && !defined $thing->ending) {
+            my $clone = $thing->clone;
+            $clone->set_ending('implicit');
+            return $clone;
+        }
+
+        return $thing unless $thing->isa('Test2::Compare::Wildcard');
+        my $newthing = _convert($thing->expect, $config);
+        $newthing->set_builder($thing->builder) unless $newthing->builder;
+        $newthing->set_file($thing->_file)      unless $newthing->_file;
+        $newthing->set_lines($thing->_lines)    unless $newthing->_lines;
+        return $newthing;
+    }
+
+    my $type = rtype($thing);
+
+    return Test2::Compare::Array->new(inref => $thing, $config->{implicit_end} ? (ending => 1) : ())
+        if $type eq 'ARRAY';
+
+    return Test2::Compare::Hash->new(inref => $thing, $config->{implicit_end} ? (ending => 1) : ())
+        if $type eq 'HASH';
+
+    return Test2::Compare::Pattern->new(
+        pattern       => $thing,
+        stringify_got => 1,
+    ) if $config->{use_regex} && $type eq 'REGEXP';
+
+    return Test2::Compare::Custom->new(code => $thing)
+        if $config->{use_code} && $type eq 'CODE';
+
+    return Test2::Compare::Regex->new(input => $thing)
+        if $type eq 'REGEXP';
+
+    if ($type eq 'SCALAR' || $type eq 'VSTRING') {
+        my $nested = _convert($$thing, $config);
+        return Test2::Compare::Scalar->new(item => $nested);
+    }
+
+    return Test2::Compare::DeepRef->new(input => $thing)
+        if $type eq 'REF';
+
+    return Test2::Compare::Ref->new(input => $thing)
+        if $type;
+
+    # is() will assume string and use 'eq'
+    return Test2::Compare::String->new(input => $thing);
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Compare - Test2 extension for writing deep comparison tools.
+
+=head1 DESCRIPTION
+
+This library is the driving force behind deep comparison tools such as
+C<Test2::Tools::Compare::is()> and
+C<Test2::Tools::ClassicCompare::is_deeply()>.
+
+=head1 SYNOPSIS
+
+    package Test2::Tools::MyCheck;
+
+    use Test2::Compare::MyCheck;
+    use Test2::Compare qw/compare/;
+
+    sub MyCheck {
+        my ($got, $exp, $name, @diag) = @_;
+        my $ctx = context();
+
+        my $delta = compare($got, $exp, \&convert);
+
+        if ($delta) {
+            $ctx->fail($name, $delta->diag, @diag);
+        }
+        else {
+            $ctx->ok(1, $name);
+        }
+
+        $ctx->release;
+        return !$delta;
+    }
+
+    sub convert {
+        my $thing = shift;
+        return $thing if blessed($thing) && $thing->isa('Test2::Compare::MyCheck');
+
+        return Test2::Compare::MyCheck->new(stuff => $thing);
+    }
+
+See L<Test2::Compare::Base> for details about writing a custom check.
+
+=head1 EXPORTS
+
+=over 4
+
+=item $delta = compare($got, $expect, \&convert)
+
+This will compare the structures in C<$got> with those in C<$expect>, The
+convert sub should convert vanilla structures inside C<$expect> into checks.
+If there are differences in the structures they will be reported back as an
+L<Test2::Compare::Delta> tree.
+
+=item $build = get_build()
+
+Get the current global build, if any.
+
+=item push_build($build)
+
+Set the current global build.
+
+=item $build = pop_build($build)
+
+Unset the current global build. This will throw an exception if the build
+passed in is different from the current global.
+
+=item build($class, sub { ... })
+
+Run the provided codeblock with a new instance of C<$class> as the current
+build. Returns the new build.
+
+=item $check = convert($thing)
+
+=item $check = convert($thing, $config)
+
+This convert function is used by C<strict_convert()> and C<relaxed_convert()>
+under the hood. It can also be used as the basis for other convert functions.
+
+If you want to use it with a custom configuration you should wrap it in another
+sub like so:
+
+    sub my_convert {
+        my $thing_to_convert = shift;
+        return convert(
+            $thing_to_convert,
+            { ... }
+        );
+    }
+
+Or the short variant:
+
+    sub my_convert { convert($_[0], { ... }) }
+
+There are several configuration options, here they are with the default setting
+listed first:
+
+=over 4
+
+=item implicit_end => 1
+
+This option toggles array/hash boundaries. If this is true then no extra hash
+keys or array indexes will be allowed. This setting affects generated compare
+objects as well as any passed in.
+
+=item use_regex => 1
+
+This option toggles regex matching. When true (default) regexes are converted
+to checks such that values must match the regex. When false regexes will be
+compared to see if they are identical regexes.
+
+=item use_code => 0
+
+This option toggles code matching. When false (default) coderefs in structures
+must be the same coderef as specified. When true coderefs will be run to verify
+the value being checked.
+
+=back
+
+=item $check = strict_convert($thing)
+
+Convert C<$thing> to an L<Test2::Compare::*> object. This will behave strictly
+which means it uses these settings:
+
+=over 4
+
+=item implicit_end => 1
+
+Array bounds will be checked when this object is used in a comparison. No
+unexpected hash keys can be present.
+
+=item use_code => 0
+
+Sub references will be compared as refs (IE are these sub refs the same ref?)
+
+=item use_regex => 0
+
+Regexes will be compared directly (IE are the regexes the same?)
+
+=back
+
+=item $compare = relaxed_convert($thing)
+
+Convert C<$thing> to an L<Test2::Compare::*> object. This will be relaxed which
+means it uses these settings:
+
+=over 4
+
+=item implicit_end => 0
+
+Array bounds will not be checked when this object is used in a comparison.
+Unexpected hash keys can be present.
+
+=item use_code => 1
+
+Sub references will be run to verify a value.
+
+=item use_regex => 1
+
+Values will be checked against any regexes provided.
+
+=back
+
+=back
+
+=head1 WRITING A VARIANT OF IS/LIKE
+
+    use Test2::Compare qw/compare convert/;
+
+    sub my_like($$;$@) {
+        my ($got, $exp, $name, @diag) = @_;
+        my $ctx = context();
+
+        # A custom converter that does the same thing as the one used by like()
+        my $convert = sub {
+            my $thing = shift;
+            return convert(
+                $thing,
+                {
+                    implicit_end => 0,
+                    use_code     => 1,
+                    use_regex    => 1,
+                }
+            );
+        };
+
+        my $delta = compare($got, $exp, $convert);
+
+        if ($delta) {
+            $ctx->fail($name, $delta->diag, @diag);
+        }
+        else {
+            $ctx->ok(1, $name);
+        }
+
+        $ctx->release;
+        return !$delta;
+    }
+
+The work of a comparison tool is done by 3 entities:
+
+=over 4
+
+=item compare()
+
+The C<compare()> function takes the structure you got, the specification you
+want to check against, and a C<\&convert> sub that will convert anything that
+is not an instance of an L<Test2::Compare::Base> subclass into one.
+
+This tool will use the C<\&convert> function on the specification, and then
+produce an L<Test2::Compare::Delta> structure that outlines all the ways the
+structure you got deviates from the specification.
+
+=item \&convert
+
+Converts anything that is not an instance of an L<Test2::Compare::Base>
+subclass, and turns it into one. The objects this produces are able to check
+that a structure matches a specification.
+
+=item $delta
+
+An instance of L<Test2::Compare::Delta> is ultimately returned. This object
+represents all the ways in with the structure you got deviated from the
+specification. The delta is a tree and may contain child deltas for nested
+structures.
+
+The delta is capable of rendering itself as a table, use C<< @lines =
+$delta->diag >> to get the table (lines in C<@lines> will not be terminated
+with C<"\n">).
+
+=back
+
+The C<convert()> function provided by this package contains all the
+specification behavior of C<like()> and C<is()>. It is intended to be wrapped
+in a sub that passes in a configuration hash, which allows you to control the
+behavior.
+
+You are free to write your own C<$check = compare($thing)> function, it just
+needs to accept a single argument, and produce a single instance of an
+L<Test2::Compare::Base> subclass.
+
+=head1 SOURCE
+
+The source code repository for Test2-Suite can be found at
+F<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/Env.pm

@@ -0,0 +1,133 @@
+package Test2::Env;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Env - Documentation for environment variables used or set by Test2.
+
+=head1 DESCRIPTION
+
+This is a list of environment variables that are either set by, or read by Test2.
+
+=head1 AUTHOR_TESTING
+
+This env var is read by Test2. When set Test2 will run tests that are normally
+skipped unless a module author is doing extra author-specific testing.
+
+=head1 AUTOMATED_TESTING
+
+This env var is read by Test2. When set this indicates the tests are run by an
+automated system and no human interaction is possible.
+
+See L<Test2::Require::AuthorTesting>.
+
+=head1 EXTENDED_TESTING
+
+This env var is read by Test2. When set it indicates some extended testing that
+should normally be skipped will be run.
+
+See L<Test2::Require::ExtendedTesting>.
+
+=head1 HARNESS_ACTIVE
+
+This env var is read by Test2. It is usually set by C<prove> (L<Test::Harness>)
+or C<yath> (L<App::Yath>).
+
+=head1 NONINTERACTIVE_TESTING
+
+This env var is read by Test2. When set this indicates the testing will not be
+interactive.
+
+See L<Test2::Require::NonInteractiveTesting>.
+
+=head1 RELEASE_TESTING
+
+This env var is read by Test2. When set this indicates that release testing is
+being done, which may run more tests than normal.
+
+See L<Test2::Require::ReleaseTesting>.
+
+=head1 T2_FORMATTER
+
+This can be used to set the formatter that Test2 will use. If set to a string
+without a '+' prefix, then 'Test2::Formatter::' will be added to the start of
+the module name. If '+' is present it will be stripped and no further
+modification will be made to the module name.
+
+=head1 T2_IN_PRELOAD
+
+Test2 sets this when preload mode is active. This is mainly used by
+L<App::Yath> and similar tools that preload Test2, then fork to run tests.
+
+=head1 TABLE_TERM_SIZE
+
+This is used to set a terminal width for things like diagnostic message tables.
+
+=head1 TEST2_ACTIVE
+
+Test2 sets this variable when tests are running.
+
+=head1 TEST2_ENABLE_PLUGINS
+
+This can be used to force plugins to be loaded whent he Test2 API is loaded. It
+takes a list of one or more plugin names seperated by comma. If the module name
+does not have a '+' in front of it then the C<Test2::Plugin::> namespace is
+assumed and added. If a '+' is present at the start of a module name it will be
+stripped and no further modification will be made.
+
+Examples:
+
+    TEST2_ENABLE_PLUGINS=BailOnFail
+    Test2_ENABLE_PLUGINS=SRand,+My::Plugin::Name
+
+=head1 TEST_ACTIVE
+
+Set by Test2 when tests are running.
+
+=head1 TS_MAX_DELTA
+
+Used to determine how many max lines of output will be provided when is() finds
+a deep data strucgture mismatch.
+
+=head1 SOURCE
+
+The source code repository for Test2-Suite can be found at
+F<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/Event.pm

@@ -0,0 +1,778 @@
+package Test2::Event;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+use Scalar::Util qw/blessed reftype/;
+use Carp qw/croak/;
+
+use Test2::Util::HashBase qw/trace -amnesty uuid -_eid -hubs/;
+use Test2::Util::ExternalMeta qw/meta get_meta set_meta delete_meta/;
+use Test2::Util qw/pkg_to_file gen_uid/;
+
+use Test2::EventFacet::About();
+use Test2::EventFacet::Amnesty();
+use Test2::EventFacet::Assert();
+use Test2::EventFacet::Control();
+use Test2::EventFacet::Error();
+use Test2::EventFacet::Info();
+use Test2::EventFacet::Meta();
+use Test2::EventFacet::Parent();
+use Test2::EventFacet::Plan();
+use Test2::EventFacet::Trace();
+use Test2::EventFacet::Hub();
+
+# Legacy tools will expect this to be loaded now
+require Test2::Util::Trace;
+
+my %LOADED_FACETS = (
+    'about'   => 'Test2::EventFacet::About',
+    'amnesty' => 'Test2::EventFacet::Amnesty',
+    'assert'  => 'Test2::EventFacet::Assert',
+    'control' => 'Test2::EventFacet::Control',
+    'errors'  => 'Test2::EventFacet::Error',
+    'info'    => 'Test2::EventFacet::Info',
+    'meta'    => 'Test2::EventFacet::Meta',
+    'parent'  => 'Test2::EventFacet::Parent',
+    'plan'    => 'Test2::EventFacet::Plan',
+    'trace'   => 'Test2::EventFacet::Trace',
+    'hubs'    => 'Test2::EventFacet::Hub',
+);
+
+sub FACET_TYPES { sort values %LOADED_FACETS }
+
+sub load_facet {
+    my $class = shift;
+    my ($facet) = @_;
+
+    return $LOADED_FACETS{$facet} if exists $LOADED_FACETS{$facet};
+
+    my @check = ($facet);
+    if ('s' eq substr($facet, -1, 1)) {
+        push @check => substr($facet, 0, -1);
+    }
+    else {
+        push @check => $facet . 's';
+    }
+
+    my $found;
+    for my $check (@check) {
+        my $mod  = "Test2::EventFacet::" . ucfirst($facet);
+        my $file = pkg_to_file($mod);
+        next unless eval { require $file; 1 };
+        $found = $mod;
+        last;
+    }
+
+    return undef unless $found;
+    $LOADED_FACETS{$facet} = $found;
+}
+
+sub causes_fail      { 0 }
+sub increments_count { 0 }
+sub diagnostics      { 0 }
+sub no_display       { 0 }
+sub subtest_id       { undef }
+
+sub callback { }
+
+sub terminate { () }
+sub global    { () }
+sub sets_plan { () }
+
+sub summary { ref($_[0]) }
+
+sub related {
+    my $self = shift;
+    my ($event) = @_;
+
+    my $tracea = $self->trace  or return undef;
+    my $traceb = $event->trace or return undef;
+
+    my $uuida = $tracea->uuid;
+    my $uuidb = $traceb->uuid;
+    if ($uuida && $uuidb) {
+        return 1 if $uuida eq $uuidb;
+        return 0;
+    }
+
+    my $siga = $tracea->signature or return undef;
+    my $sigb = $traceb->signature or return undef;
+
+    return 1 if $siga eq $sigb;
+    return 0;
+}
+
+sub add_hub {
+    my $self = shift;
+    unshift @{$self->{+HUBS}} => @_;
+}
+
+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;
+    }
+}
+
+sub eid { $_[0]->{+_EID} ||= gen_uid() }
+
+sub common_facet_data {
+    my $self = shift;
+
+    my %out;
+
+    $out{about} = {package => ref($self) || undef};
+    if (my $uuid = $self->uuid) {
+        $out{about}->{uuid} = $uuid;
+    }
+
+    $out{about}->{eid} = $self->{+_EID} || $self->eid;
+
+    if (my $trace = $self->trace) {
+        $out{trace} = { %$trace };
+    }
+
+    if (my $hubs = $self->hubs) {
+        $out{hubs} = $hubs;
+    }
+
+    $out{amnesty} = [map {{ %{$_} }} @{$self->{+AMNESTY}}]
+        if $self->{+AMNESTY};
+
+    if (my $meta = $self->meta_facet_data) {
+        $out{meta} = $meta;
+    }
+
+    return \%out;
+}
+
+sub meta_facet_data {
+    my $self = shift;
+
+    my $key = Test2::Util::ExternalMeta::META_KEY();
+
+    my $hash = $self->{$key} or return undef;
+    return {%$hash};
+}
+
+sub facet_data {
+    my $self = shift;
+
+    my $out = $self->common_facet_data;
+
+    $out->{about}->{details}    = $self->summary    || undef;
+    $out->{about}->{no_display} = $self->no_display || undef;
+
+    # Might be undef, we want to preserve that
+    my $terminate = $self->terminate;
+    $out->{control} = {
+        global    => $self->global    || 0,
+        terminate => $terminate,
+        has_callback => $self->can('callback') == \&callback ? 0 : 1,
+    };
+
+    $out->{assert} = {
+        no_debug => 1,                     # Legacy behavior
+        pass     => $self->causes_fail ? 0 : 1,
+        details  => $self->summary,
+    } if $self->increments_count;
+
+    $out->{parent} = {hid => $self->subtest_id} if $self->subtest_id;
+
+    if (my @plan = $self->sets_plan) {
+        $out->{plan} = {};
+
+        $out->{plan}->{count}   = $plan[0] if defined $plan[0];
+        $out->{plan}->{details} = $plan[2] if defined $plan[2];
+
+        if ($plan[1]) {
+            $out->{plan}->{skip} = 1 if $plan[1] eq 'SKIP';
+            $out->{plan}->{none} = 1 if $plan[1] eq 'NO PLAN';
+        }
+
+        $out->{control}->{terminate} ||= 0 if $out->{plan}->{skip};
+    }
+
+    if ($self->causes_fail && !$out->{assert}) {
+        $out->{errors} = [
+            {
+                tag     => 'FAIL',
+                fail    => 1,
+                details => $self->summary,
+            }
+        ];
+    }
+
+    my %IGNORE = (trace => 1, about => 1, control => 1);
+    my $do_info = !grep { !$IGNORE{$_} } keys %$out;
+
+    if ($do_info && !$self->no_display && $self->diagnostics) {
+        $out->{info} = [
+            {
+                tag     => 'DIAG',
+                debug   => 1,
+                details => $self->summary,
+            }
+        ];
+    }
+
+    return $out;
+}
+
+sub facets {
+    my $self = shift;
+    my %out;
+
+    my $data = $self->facet_data;
+    my @errors = $self->validate_facet_data($data);
+    die join "\n" => @errors if @errors;
+
+    for my $facet (keys %$data) {
+        my $class = $self->load_facet($facet);
+        my $val = $data->{$facet};
+
+        unless($class) {
+            $out{$facet} = $val;
+            next;
+        }
+
+        my $is_list = reftype($val) eq 'ARRAY' ? 1 : 0;
+        if ($is_list) {
+            $out{$facet} = [map { $class->new($_) } @$val];
+        }
+        else {
+            $out{$facet} = $class->new($val);
+        }
+    }
+
+    return \%out;
+}
+
+sub validate_facet_data {
+    my $class_or_self = shift;
+    my ($f, %params);
+
+    $f = shift if @_ && (reftype($_[0]) || '') eq 'HASH';
+    %params = @_;
+
+    $f ||= $class_or_self->facet_data if blessed($class_or_self);
+    croak "No facet data" unless $f;
+
+    my @errors;
+
+    for my $k (sort keys %$f) {
+        my $fclass = $class_or_self->load_facet($k);
+
+        push @errors => "Could not find a facet class for facet '$k'"
+            if $params{require_facet_class} && !$fclass;
+
+        next unless $fclass;
+
+        my $v = $f->{$k};
+        next unless defined($v); # undef is always fine
+
+        my $is_list = $fclass->is_list();
+        my $got_list = reftype($v) eq 'ARRAY' ? 1 : 0;
+
+        push @errors => "Facet '$k' should be a list, but got a single item ($v)"
+            if $is_list && !$got_list;
+
+        push @errors => "Facet '$k' should not be a list, but got a a list ($v)"
+            if $got_list && !$is_list;
+    }
+
+    return @errors;
+}
+
+sub nested {
+    my $self = shift;
+
+    Carp::cluck("Use of Test2::Event->nested() is deprecated, use Test2::Event->trace->nested instead")
+        if $ENV{AUTHOR_TESTING};
+
+    if (my $hubs = $self->{+HUBS}) {
+        return $hubs->[0]->{nested} if @$hubs;
+    }
+
+    my $trace = $self->{+TRACE} or return undef;
+    return $trace->{nested};
+}
+
+sub in_subtest {
+    my $self = shift;
+
+    Carp::cluck("Use of Test2::Event->in_subtest() is deprecated, use Test2::Event->trace->hid instead")
+        if $ENV{AUTHOR_TESTING};
+
+    my $hubs = $self->{+HUBS};
+    if ($hubs && @$hubs) {
+        return undef unless $hubs->[0]->{nested};
+        return $hubs->[0]->{hid}
+    }
+
+    my $trace = $self->{+TRACE} or return undef;
+    return undef unless $trace->{nested};
+    return $trace->{hid};
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::Event - Base class for events
+
+=head1 DESCRIPTION
+
+Base class for all event objects that get passed through
+L<Test2>.
+
+=head1 SYNOPSIS
+
+    package Test2::Event::MyEvent;
+    use strict;
+    use warnings;
+
+    # This will make our class an event subclass (required)
+    use base 'Test2::Event';
+
+    # Add some accessors (optional)
+    # You are not obligated to use HashBase, you can use any object tool you
+    # want, or roll your own accessors.
+    use Test2::Util::HashBase qw/foo bar baz/;
+
+    # Use this if you want the legacy API to be written for you, for this to
+    # work you will need to implement a facet_data() method.
+    use Test2::Util::Facets2Legacy;
+
+    # Chance to initialize some defaults
+    sub init {
+        my $self = shift;
+        # no other args in @_
+
+        $self->set_foo('xxx') unless defined $self->foo;
+
+        ...
+    }
+
+    # This is the new way for events to convey data to the Test2 system
+    sub facet_data {
+        my $self = shift;
+
+        # Get common facets such as 'about', 'trace' 'amnesty', and 'meta'
+        my $facet_data = $self->common_facet_data();
+
+        # Are you making an assertion?
+        $facet_data->{assert} = {pass => 1, details => 'my assertion'};
+        ...
+
+        return $facet_data;
+    }
+
+    1;
+
+=head1 METHODS
+
+=head2 GENERAL
+
+=over 4
+
+=item $trace = $e->trace
+
+Get a snapshot of the L<Test2::EventFacet::Trace> as it was when this event was
+generated
+
+=item $bool_or_undef = $e->related($e2)
+
+Check if 2 events are related. In this case related means their traces share a
+signature meaning they were created with the same context (or at the very least
+by contexts which share an id, which is the same thing unless someone is doing
+something very bad).
+
+This can be used to reliably link multiple events created by the same tool. For
+instance a failing test like C<ok(0, "fail"> will generate 2 events, one being
+a L<Test2::Event::Ok>, the other being a L<Test2::Event::Diag>, both of these
+events are related having been created under the same context and by the same
+initial tool (though multiple tools may have been nested under the initial
+one).
+
+This will return C<undef> if the relationship cannot be checked, which happens
+if either event has an incomplete or missing trace. This will return C<0> if
+the traces are complete, but do not match. C<1> will be returned if there is a
+match.
+
+=item $e->add_amnesty({tag => $TAG, details => $DETAILS});
+
+This can be used to add amnesty to this event. Amnesty only affects failing
+assertions in most cases, but some formatters may display them for passing
+assertions, or even non-assertions as well.
+
+Amnesty will prevent a failed assertion from causing the overall test to fail.
+In other words it marks a failure as expected and allowed.
+
+B<Note:> This is how 'TODO' is implemented under the hood. TODO is essentially
+amnesty with the 'TODO' tag. The details are the reason for the TODO.
+
+=item $uuid = $e->uuid
+
+If UUID tagging is enabled (See L<Test::API>) then any event that has made its
+way through a hub will be tagged with a UUID. A newly created event will not
+yet be tagged in most cases.
+
+=item $class = $e->load_facet($name)
+
+This method is used to load a facet by name (or key). It will attempt to load
+the facet class, if it succeeds it will return the class it loaded. If it fails
+it will return C<undef>. This caches the result at the class level so that
+future calls will be faster.
+
+The C<$name> variable should be the key used to access the facet in a facets
+hashref. For instance the assertion facet has the key 'assert', the information
+facet has the 'info' key, and the error facet has the key 'errors'. You may
+include or omit the 's' at the end of the name, the method is smart enough to
+try both the 's' and no-'s' forms, it will check what you provided first, and
+if that is not found it will add or strip the 's and try again.
+
+=item @classes = $e->FACET_TYPES()
+
+=item @classes = Test2::Event->FACET_TYPES()
+
+This returns a list of all facets that have been loaded using the
+C<load_facet()> method. This will not return any classes that have not been
+loaded, or have been loaded directly without a call to C<load_facet()>.
+
+B<Note:> The core facet types are automatically loaded and populated in this
+list.
+
+=back
+
+=head2 NEW API
+
+=over 4
+
+=item $hashref = $e->common_facet_data();
+
+This can be used by subclasses to generate a starting facet data hashref. This
+will populate the hashref with the trace, meta, amnesty, and about facets.
+These facets are nearly always produced the same way for all events.
+
+=item $hashref = $e->facet_data()
+
+If you do not override this then the default implementation will attempt to
+generate facets from the legacy API. This generation is limited only to what
+the legacy API can provide. It is recommended that you override this method and
+write out explicit facet data.
+
+=item $hashref = $e->facets()
+
+This takes the hashref from C<facet_data()> and blesses each facet into the
+proper C<Test2::EventFacet::*> subclass. If no class can be found for any given
+facet it will be passed along unchanged.
+
+=item @errors = $e->validate_facet_data();
+
+=item @errors = $e->validate_facet_data(%params);
+
+=item @errors = $e->validate_facet_data(\%facets, %params);
+
+=item @errors = Test2::Event->validate_facet_data(%params);
+
+=item @errors = Test2::Event->validate_facet_data(\%facets, %params);
+
+This method will validate facet data and return a list of errors. If no errors
+are found this will return an empty list.
+
+This can be called as an object method with no arguments, in which case the
+C<facet_data()> method will be called to get the facet data to be validated.
+
+When used as an object method the C<\%facet_data> argument may be omitted.
+
+When used as a class method the C<\%facet_data> argument is required.
+
+Remaining arguments will be slurped into a C<%params> hash.
+
+Currently only 1 parameter is defined:
+
+=over 4
+
+=item require_facet_class => $BOOL
+
+When set to true (default is false) this will reject any facets where a facet
+class cannot be found. Normally facets without classes are assumed to be custom
+and are ignored.
+
+=back
+
+=back
+
+=head3 WHAT ARE FACETS?
+
+Facets are how events convey their purpose to the Test2 internals and
+formatters. An event without facets will have no intentional effect on the
+overall test state, and will not be displayed at all by most formatters, except
+perhaps to say that an event of an unknown type was seen.
+
+Facets are produced by the C<facet_data()> subroutine, which you should
+nearly-always override. C<facet_data()> is expected to return a hashref where
+each key is the facet type, and the value is either a hashref with the data for
+that facet, or an array of hashrefs. Some facets must be defined as single
+hashrefs, some must be defined as an array of hashrefs, No facets allow both.
+
+C<facet_data()> B<MUST NOT> bless the data it returns, the main hashref, and
+nested facet hashrefs B<MUST> be bare, though items contained within each
+facet may be blessed. The data returned by this method B<should> also be copies
+of the internal data in order to prevent accidental state modification.
+
+C<facets()> takes the data from C<facet_data()> and blesses it into the
+C<Test2::EventFacet::*> packages. This is rarely used however, the EventFacet
+packages are primarily for convenience and documentation. The EventFacet
+classes are not used at all internally, instead the raw data is used.
+
+Here is a list of facet types by package. The packages are not used internally,
+but are where the documentation for each type is kept.
+
+B<Note:> Every single facet type has the C<'details'> field. This field is
+always intended for human consumption, and when provided, should explain the
+'why' for the facet. All other fields are facet specific.
+
+=over 4
+
+=item about => {...}
+
+L<Test2::EventFacet::About>
+
+This contains information about the event itself such as the event package
+name. The C<details> field for this facet is an overall summary of the event.
+
+=item assert => {...}
+
+L<Test2::EventFacet::Assert>
+
+This facet is used if an assertion was made. The C<details> field of this facet
+is the description of the assertion.
+
+=item control => {...}
+
+L<Test2::EventFacet::Control>
+
+This facet is used to tell the L<Test2::Event::Hub> about special actions the
+event causes. Things like halting all testing, terminating the current test,
+etc. In this facet the C<details> field explains why any special action was
+taken.
+
+B<Note:> This is how bail-out is implemented.
+
+=item meta => {...}
+
+L<Test2::EventFacet::Meta>
+
+The meta facet contains all the meta-data attached to the event. In this case
+the C<details> field has no special meaning, but may be present if something
+sets the 'details' meta-key on the event.
+
+=item parent => {...}
+
+L<Test2::EventFacet::Parent>
+
+This facet contains nested events and similar details for subtests. In this
+facet the C<details> field will typically be the name of the subtest.
+
+=item plan => {...}
+
+L<Test2::EventFacet::Plan>
+
+This facet tells the system that a plan has been set. The C<details> field of
+this is usually left empty, but when present explains why the plan is what it
+is, this is most useful if the plan is to skip-all.
+
+=item trace => {...}
+
+L<Test2::EventFacet::Trace>
+
+This facet contains information related to when and where the event was
+generated. This is how the test file and line number of a failure is known.
+This facet can also help you to tell if tests are related.
+
+In this facet the C<details> field overrides the "failed at test_file.t line
+42." message provided on assertion failure.
+
+=item amnesty => [{...}, ...]
+
+L<Test2::EventFacet::Amnesty>
+
+The amnesty facet is a list instead of a single item, this is important as
+amnesty can come from multiple places at once.
+
+For each instance of amnesty the C<details> field explains why amnesty was
+granted.
+
+B<Note:> Outside of formatters amnesty only acts to forgive a failing
+assertion.
+
+=item errors => [{...}, ...]
+
+L<Test2::EventFacet::Error>
+
+The errors facet is a list instead of a single item, any number of errors can
+be listed. In this facet C<details> describes the error, or may contain the raw
+error message itself (such as an exception). In perl exception may be blessed
+objects, as such the raw data for this facet may contain nested items which are
+blessed.
+
+Not all errors are considered fatal, there is a C<fail> field that must be set
+for an error to cause the test to fail.
+
+B<Note:> This facet is unique in that the field name is 'errors' while the
+package is 'Error'. This is because this is the only facet type that is both a
+list, and has a name where the plural is not the same as the singular. This may
+cause some confusion, but I feel it will be less confusing than the
+alternative.
+
+=item info => [{...}, ...]
+
+L<Test2::EventFacet::Info>
+
+The 'info' facet is a list instead of a single item, any quantity of extra
+information can be attached to an event. Some information may be critical
+diagnostics, others may be simply commentary in nature, this is determined by
+the C<debug> flag.
+
+For this facet the C<details> flag is the info itself. This info may be a
+string, or it may be a data structure to display. This is one of the few facet
+types that may contain blessed items.
+
+=back
+
+=head2 LEGACY API
+
+=over 4
+
+=item $bool = $e->causes_fail
+
+Returns true if this event should result in a test failure. In general this
+should be false.
+
+=item $bool = $e->increments_count
+
+Should be true if this event should result in a test count increment.
+
+=item $e->callback($hub)
+
+If your event needs to have extra effects on the L<Test2::Hub> you can override
+this method.
+
+This is called B<BEFORE> your event is passed to the formatter.
+
+=item $num = $e->nested
+
+If this event is nested inside of other events, this should be the depth of
+nesting. (This is mainly for subtests)
+
+=item $bool = $e->global
+
+Set this to true if your event is global, that is ALL threads and processes
+should see it no matter when or where it is generated. This is not a common
+thing to want, it is used by bail-out and skip_all to end testing.
+
+=item $code = $e->terminate
+
+This is called B<AFTER> your event has been passed to the formatter. This
+should normally return undef, only change this if your event should cause the
+test to exit immediately.
+
+If you want this event to cause the test to exit you should return the exit
+code here. Exit code of 0 means exit success, any other integer means exit with
+failure.
+
+This is used by L<Test2::Event::Plan> to exit 0 when the plan is
+'skip_all'. This is also used by L<Test2::Event:Bail> to force the test
+to exit with a failure.
+
+This is called after the event has been sent to the formatter in order to
+ensure the event is seen and understood.
+
+=item $msg = $e->summary
+
+This is intended to be a human readable summary of the event. This should
+ideally only be one line long, but you can use multiple lines if necessary. This
+is intended for human consumption. You do not need to make it easy for machines
+to understand.
+
+The default is to simply return the event package name.
+
+=item ($count, $directive, $reason) = $e->sets_plan()
+
+Check if this event sets the testing plan. It will return an empty list if it
+does not. If it does set the plan it will return a list of 1 to 3 items in
+order: Expected Test Count, Test Directive, Reason for directive.
+
+=item $bool = $e->diagnostics
+
+True if the event contains diagnostics info. This is useful because a
+non-verbose harness may choose to hide events that are not in this category.
+Some formatters may choose to send these to STDERR instead of STDOUT to ensure
+they are seen.
+
+=item $bool = $e->no_display
+
+False by default. This will return true on events that should not be displayed
+by formatters.
+
+=item $id = $e->in_subtest
+
+If the event is inside a subtest this should have the subtest ID.
+
+=item $id = $e->subtest_id
+
+If the event is a final subtest event, this should contain the subtest ID.
+
+=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
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut

git/usr/share/perl5/core_perl/Test2/EventFacet.pm

@@ -0,0 +1,93 @@
+package Test2::EventFacet;
+use strict;
+use warnings;
+
+our $VERSION = '1.302210';
+
+use Test2::Util::HashBase qw/-details/;
+use Carp qw/croak/;
+
+my $SUBLEN = length(__PACKAGE__ . '::');
+sub facet_key {
+    my $key = ref($_[0]) || $_[0];
+    substr($key, 0, $SUBLEN, '');
+    return lc($key);
+}
+
+sub is_list { 0 }
+
+sub clone {
+    my $self = shift;
+    my $type = ref($self);
+    return bless {%$self, @_}, $type;
+}
+
+1;
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Test2::EventFacet - Base class for all event facets.
+
+=head1 DESCRIPTION
+
+Base class for all event facets.
+
+=head1 METHODS
+
+=over 4
+
+=item $key = $facet_class->facet_key()
+
+This will return the key for the facet in the facet data hash.
+
+=item $bool = $facet_class->is_list()
+
+This will return true if the facet should be in a list instead of a single
+item.
+
+=item $clone = $facet->clone()
+
+=item $clone = $facet->clone(%replace)
+
+This will make a shallow clone of the facet. You may specify fields to override
+as arguments.
+
+=back
+
+=head1 SOURCE
+
+The source code repository for Test2 can be found at
+L<https://github.com/Test-More/test-more/>.
+
+=head1 MAINTAINERS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 AUTHORS
+
+=over 4
+
+=item Chad Granum E<lt>exodist@cpan.orgE<gt>
+
+=back
+
+=head1 COPYRIGHT
+
+Copyright Chad Granum E<lt>exodist@cpan.orgE<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See L<https://dev.perl.org/licenses/>
+
+=cut