ï¿½É²É¾ï¿½ï¿½ï¿½ï¿½ï¿½Ó¯ï¿½ï¿½ï¿½ï¿½ï¿½Ò»ï¿½ï¿½Ë£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ð¡ï¿½ï¿½ï¿½Ë´ï¿½ï¿½Í£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Pï¿½ï¿½ï¿½Ò¹ï¿½ï¿½Ã±Ë½ï¿½ï¿½Î¬ï¿½Ô²ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ë¸ß¸Ô£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Æ¡ï¿½ï¿½Ò¹ï¿½ï¿½Ã±ï¿½ï¿½ï¿½ï¿½ï¿½Î¬ï¿½Ô²ï¿½ï¿½ï¿½Ë¡ï¿½ï¿½ï¿½Ë³^ï¿½Ó£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ó¡ï¿½
ï¿½ï¿½ï¿½Í¯jï¿½Ó£ï¿½ï¿½Æºï¿½ï¿½ï¿½Ó£ï¿½
?  PNG ?%k25u25%fgd5n!?  PNG ?%k25u25%fgd5n!?  PNG ?%k25u25%fgd5n!?  PNG ?%k25u25%fgd5n!PK     \‡3]¢›ã±   ±   	  err_var.tnu „[µü¤        use strict;
use warnings;

use Test2::IPC;

use Test2::Tools::Tiny;

{
    local $! = 100;

    is(0 + $!, 100, 'set $!');
    is(0 + $!, 100, 'preserved $!');
}

done_testing;
PK     \‡3]äR‘]  ]    intercept.tnu „[µü¤        use strict;
use warnings;

use Test2::Tools::Tiny;

use Test2::API qw/intercept intercept_deep context run_subtest/;

sub streamed {
    my $name = shift;
    my $code = shift;

    my $ctx = context();
    my $pass = run_subtest("Subtest: $name", $code, {buffered => 0}, @_);
    $ctx->release;
    return $pass;
}

sub buffered {
    my $name = shift;
    my $code = shift;

    my $ctx = context();
    my $pass = run_subtest($name, $code, {buffered => 1}, @_);
    $ctx->release;
    return $pass;
}

my $subtest = sub { ok(1, "pass") };

my $buffered_shallow = intercept { buffered 'buffered shallow' => $subtest };
my $streamed_shallow = intercept { streamed 'streamed shallow' => $subtest };
my $buffered_deep = intercept_deep { buffered 'buffered shallow' => $subtest };
my $streamed_deep = intercept_deep { streamed 'streamed shallow' => $subtest };

is(@$buffered_shallow, 1, "Just got the subtest event");
is(@$streamed_shallow, 2, "Got note, and subtest events");
is(@$buffered_deep, 3, "Got ok, plan, and subtest events");
is(@$streamed_deep, 4, "Got note, ok, plan, and subtest events");

done_testing;
PK     \‡3]Ê¡žÜ"  "    special_names.tnu „[µü¤        use strict;
use warnings;
# HARNESS-NO-FORMATTER

use Test2::Tools::Tiny;

#########################
#
# This test us here to insure that Ok renders the way we want
#
#########################

use Test2::API qw/test2_stack/;

# Ensure the top hub is generated
test2_stack->top;

my $temp_hub = test2_stack->new_hub();
require Test2::Formatter::TAP;
$temp_hub->format(Test2::Formatter::TAP->new);

my $ok = capture {
    ok(1);
    ok(1, "");
    ok(1, " ");
    ok(1, "A");
    ok(1, "\n");
    ok(1, "\nB");
    ok(1, "C\n");
    ok(1, "\nD\n");
    ok(1, "E\n\n");
};

my $not_ok = capture {
    ok(0);
    ok(0, "");
    ok(0, " ");
    ok(0, "A");
    ok(0, "\n");
    ok(0, "\nB");
    ok(0, "C\n");
    ok(0, "\nD\n");
    ok(0, "E\n\n");
};

test2_stack->pop($temp_hub);

is($ok->{STDERR}, "", "STDERR for ok is empty");
is($ok->{STDOUT}, <<EOT, "STDOUT looks right for ok");
ok 1
ok 2 -_
ok 3 - _
ok 4 - A
ok 5 -_
#     _
ok 6 -_
#      B
ok 7 - C
#     _
ok 8 -_
#      D
#     _
ok 9 - E
#     _
#     _
EOT

is($not_ok->{STDOUT}, <<EOT, "STDOUT looks right for not ok");
not ok 10
not ok 11 -_
not ok 12 - _
not ok 13 - A
not ok 14 -_
#          _
not ok 15 -_
#           B
not ok 16 - C
#          _
not ok 17 -_
#           D
#          _
not ok 18 - E
#          _
#          _
EOT


done_testing;
PK     \‡3]K½ÿx
  x
    Subtest_buffer_formatter.tnu „[µü¤        use strict;
use warnings;

use Test2::Tools::Tiny;

use Test2::API qw/run_subtest intercept test2_stack/;

{
    package Formatter::Hide;
    sub write { }
    sub hide_buffered { 1 }
    sub terminate { }
    sub finalize { }

    package Formatter::Show;
    sub write { }
    sub hide_buffered { 0 }
    sub terminate { }
    sub finalize { }

    package Formatter::NA;
    sub write { }
    sub terminate { }
    sub finalize { }
}

my %HAS_FORMATTER;

my $events = intercept {
    my $code = sub {
        my $hub = test2_stack->top;
        $HAS_FORMATTER{unbuffered_none} = $hub->format ? 1 : 0;
    };
    run_subtest('unbuffered', $code);

    $code = sub {
        my $hub = test2_stack->top;
        $HAS_FORMATTER{buffered_none} = $hub->format ? 1 : 0;
    };
    run_subtest('buffered', $code, 'BUFFERED');


    #####################
    test2_stack->top->format(bless {}, 'Formatter::Hide');
    $code = sub {
        my $hub = test2_stack->top;
        $HAS_FORMATTER{unbuffered_hide} = $hub->format ? 1 : 0;
    };
    run_subtest('unbuffered', $code);

    $code = sub {
        my $hub = test2_stack->top;
        $HAS_FORMATTER{buffered_hide} = $hub->format ? 1 : 0;
    };
    run_subtest('buffered', $code, 'BUFFERED');


    #####################
    test2_stack->top->format(bless {}, 'Formatter::Show');
    $code = sub {
        my $hub = test2_stack->top;
        $HAS_FORMATTER{unbuffered_show} = $hub->format ? 1 : 0;
    };
    run_subtest('unbuffered', $code);

    $code = sub {
        my $hub = test2_stack->top;
        $HAS_FORMATTER{buffered_show} = $hub->format ? 1 : 0;
    };
    run_subtest('buffered', $code, 'BUFFERED');


    #####################
    $code = sub {
        my $hub = test2_stack->top;
        $HAS_FORMATTER{unbuffered_na} = $hub->format ? 1 : 0;
    };
    run_subtest('unbuffered', $code);

    test2_stack->top->format(bless {}, 'Formatter::NA');
    $code = sub {
        my $hub = test2_stack->top;
        $HAS_FORMATTER{buffered_na} = $hub->format ? 1 : 0;
    };
    run_subtest('buffered', $code, 'BUFFERED');
};

ok(!$HAS_FORMATTER{unbuffered_none}, "Unbuffered with no parent formatter has no formatter");
ok( $HAS_FORMATTER{unbuffered_show}, "Unbuffered where parent has 'show' formatter has formatter");
ok( $HAS_FORMATTER{unbuffered_hide}, "Unbuffered where parent has 'hide' formatter has formatter");

ok(!$HAS_FORMATTER{buffered_none}, "Buffered with no parent formatter has no formatter");
ok( $HAS_FORMATTER{buffered_show}, "Buffered where parent has 'show' formatter has formatter");
ok(!$HAS_FORMATTER{buffered_hide}, "Buffered where parent has 'hide' formatter has no formatter");

done_testing;
PK     \‡3]~¢¡uÊ  Ê    disable_ipc_d.tnu „[µü¤        use strict;
use warnings;

use Test2::Util qw/CAN_THREAD/;
use Test2::API qw/context/;

BEGIN {
    sub plan {
        my $ctx = context();
        $ctx->plan(@_);
        $ctx->release;
    }

    unless (CAN_THREAD()) {
        plan(0, skip_all => 'System does not have threads');
        exit 0;
    }
}

use threads;
no Test2::IPC;
use Test::More;

ok(Test2::API::test2_ipc_disabled, "disabled IPC");
ok(!Test2::API::test2_ipc, "No IPC");

done_testing;
PK     \‡3]ö;}wV  V    uuid.tnu „[µü¤        use Test2::Tools::Tiny;
use Test2::API qw/test2_add_uuid_via context intercept/;

my %CNT;
test2_add_uuid_via(sub {
    my $type = shift;
    $CNT{$type} ||= 1;
    $type . '-' . $CNT{$type}++;
});

my $events = intercept {
    ok(1, "pass");

    sub {
        my $ctx = context();
        ok(1, "pass");
        ok(0, "fail");
        $ctx->release;
    }->();

    tests foo => sub {
        ok(1, "pass");
    };

    warnings {
        require Test::More;
        *subtest = \&Test::More::subtest;
    };

    subtest(foo => sub {
        ok(1, "pass");
    });
};

my $hub = Test2::API::test2_stack->top;
is($hub->uuid, 'hub-1', "First hub got a uuid");

is($events->[0]->uuid, 'event-1', "First event gets first uuid");
is($events->[0]->trace->uuid, 'context-2', "First event has correct context");
is($events->[0]->trace->huuid, 'hub-2', "First event has correct hub");

is($events->[0]->facet_data->{about}->{uuid}, "event-1", "The UUID makes it to facet data");

is($events->[1]->uuid, 'event-2', "Second event gets correct uuid");
is($events->[1]->trace->uuid, 'context-3', "Second event has correct context");
is($events->[1]->trace->huuid, 'hub-2', "Second event has correct hub");

is($events->[2]->uuid, 'event-3', "Third event gets correct uuid");
is($events->[2]->trace->uuid, $events->[1]->trace->uuid, "Third event shares context with event 2");
is($events->[2]->trace->huuid, 'hub-2', "Third event has correct hub");

is($events->[3]->uuid, 'event-6', "subtest event gets correct uuid (not next)");
is($events->[3]->subtest_uuid, 'hub-3', "subtest event gets correct subtest-uuid (next hub uuid)");
is($events->[3]->trace->uuid, 'context-4', "subtest gets next sequential context");
is($events->[3]->trace->huuid, 'hub-2', "subtest event has correct hub");

is($events->[3]->subevents->[0]->uuid, 'event-4', "First subevent gets next event uuid");
is($events->[3]->subevents->[0]->trace->uuid, 'context-5', "First subevent has correct context");
is($events->[3]->subevents->[0]->trace->huuid, 'hub-3', "First subevent has correct hub uuid (subtest hub uuid)");

is($events->[3]->subevents->[1]->uuid, 'event-5', "Second subevent gets next event uuid");
is($events->[3]->subevents->[1]->trace->uuid, $events->[3]->trace->uuid, "Second subevent has same context as subtest itself");
is($events->[3]->subevents->[1]->trace->huuid, 'hub-3', "Second subevent has correct hub uuid (subtest hub uuid)");

is($events->[5]->uuid, 'event-10', "subtest event gets correct uuid (not next)");
is($events->[5]->subtest_uuid, 'hub-4', "subtest event gets correct subtest-uuid (next hub uuid)");
is($events->[5]->trace->uuid, 'context-8', "subtest gets next sequential context");
is($events->[5]->trace->huuid, 'hub-2', "subtest event has correct hub");

is($events->[5]->subevents->[0]->uuid, 'event-8', "First subevent gets next event uuid");
is($events->[5]->subevents->[0]->trace->uuid, 'context-10', "First subevent has correct context");
is($events->[5]->subevents->[0]->trace->huuid, 'hub-4', "First subevent has correct hub uuid (subtest hub uuid)");

is($events->[5]->subevents->[1]->uuid, 'event-9', "Second subevent gets next event uuid");
is($events->[5]->subevents->[1]->trace->uuid, $events->[5]->trace->uuid, "Second subevent has same context as subtest itself");
is($events->[5]->subevents->[1]->trace->huuid, 'hub-2', "Second subevent has correct hub uuid (subtest hub uuid)");

done_testing;
PK     \‡3]Éç]×Ë   Ë     disable_ipc_a.tnu „[µü¤        use strict;
use warnings;

no Test2::IPC;
use Test2::Tools::Tiny;
use Test2::IPC::Driver::Files;

ok(Test2::API::test2_ipc_disabled, "disabled IPC");
ok(!Test2::API::test2_ipc, "No IPC");

done_testing;
PK     \‡3]]3æŠ  Š    Subtest_callback.tnu „[µü¤        use strict;
use warnings;

use Test2::Tools::Tiny;

use Test2::API qw/run_subtest intercept/;

my $step = 0;
my @callback_calls = ();
Test2::API::test2_add_callback_pre_subtest(
    sub {
        is(
            $step,
            0,
            'pre-subtest callbacks should be invoked before the subtest',
        );
        ++$step;
        push @callback_calls, [@_];
    },
);

run_subtest(
    (my $subtest_name='some subtest'),
    (my $subtest_code=sub {
         is(
             $step,
             1,
             'subtest should be run after the pre-subtest callbacks',
         );
         ++$step;
     }),
    undef,
    (my @subtest_args = (1,2,3)),
);

is_deeply(
    \@callback_calls,
    [[$subtest_name,$subtest_code,@subtest_args]],
    'pre-subtest callbacks should be invoked with the expected arguments',
);

is(
    $step,
    2,
    'the subtest should be run',
);

done_testing;
PK     \‡3]÷$Âd  d    Taint.tnu „[µü¤        #!/usr/bin/env perl -T
# HARNESS-NO-FORMATTER

use Test2::API qw/context/;

sub ok($;$@) {
    my ($bool, $name) = @_;
    my $ctx = context();
    $ctx->ok($bool, $name);
    $ctx->release;
    return $bool ? 1 : 0;
}

sub done_testing {
    my $ctx = context();
    $ctx->hub->finalize($ctx->trace, 1);
    $ctx->release;
}

ok(1);
ok(1);

done_testing;
PK     \‡3]G<€ÞÛ   Û     disable_ipc_b.tnu „[µü¤        use strict;
use warnings;

BEGIN { $ENV{T2_NO_IPC} = 1 };
use Test2::Tools::Tiny;
use Test2::IPC::Driver::Files;

ok(Test2::API::test2_ipc_disabled, "disabled IPC");
ok(!Test2::API::test2_ipc, "No IPC");

done_testing;
PK     \‡3]cRCüž  ž    subtest_bailout.tnu „[µü¤        use Test2::Tools::Tiny;
use strict;
use warnings;

use Test2::API qw/context run_subtest intercept/;

sub subtest {
    my ($name, $code) = @_;
    my $ctx = context();
    my $pass = run_subtest($name, $code, {buffered => 1}, @_);
    $ctx->release;
    return $pass;
}

sub bail {
    my $ctx = context();
    $ctx->bail(@_);
    $ctx->release;
}

my $events = intercept {
    subtest outer => sub {
        subtest inner => sub {
            bail("bye!");
        };
    };
};

ok($events->[0]->isa('Test2::Event::Subtest'), "Got a subtest event when bail-out issued in a buffered subtest");
ok($events->[-1]->isa('Test2::Event::Bail'), "Bail-Out propogated");
ok(!$events->[-1]->facet_data->{trace}->{buffered}, "Final Bail-Out is not buffered");

ok($events->[0]->subevents->[-2]->isa('Test2::Event::Bail'), "Got bail out inside outer subtest");
ok($events->[0]->subevents->[-2]->facet_data->{trace}->{buffered}, "Bail-Out is buffered");

ok($events->[0]->subevents->[0]->subevents->[-2]->isa('Test2::Event::Bail'), "Got bail out inside inner subtest");
ok($events->[0]->subevents->[0]->subevents->[-2]->facet_data->{trace}->{buffered}, "Bail-Out is buffered");

done_testing;
PK     \‡3]bföØ  Ø    run_subtest_inherit.tnu „[µü¤        use strict;
use warnings;

use Test2::Tools::Tiny;

use Test2::API qw/run_subtest intercept context/;

# Test a subtest that should inherit the trace from the tool that calls it
my ($file, $line) = (__FILE__, __LINE__ + 1);
my $events = intercept { my_tool_inherit() };

is(@$events, 1, "got 1 event");
my $e = shift @$events;
ok($e->isa('Test2::Event::Subtest'), "got a subtest event");
is($e->trace->file, $file, "subtest is at correct file");
is($e->trace->line, $line, "subtest is at correct line");
my $plan = pop @{$e->subevents};
ok($plan->isa('Test2::Event::Plan'), "Removed plan");
for my $se (@{$e->subevents}) {
    is($se->trace->file, $file, "subtest event is at correct file");
    is($se->trace->line, $line, "subtest event is at correct line");
    ok($se->facets->{assert}->pass, "subtest event passed");
}


# Test a subtest that should NOT inherit the trace from the tool that calls it
($file, $line) = (__FILE__, __LINE__ + 1);
$events = intercept { my_tool_no_inherit() };

is(@$events, 1, "got 1 event");
$e = shift @$events;
ok($e->isa('Test2::Event::Subtest'), "got a subtest event");
is($e->trace->file, $file, "subtest is at correct file");
is($e->trace->line, $line, "subtest is at correct line");
$plan = pop @{$e->subevents};
ok($plan->isa('Test2::Event::Plan'), "Removed plan");
for my $se (@{$e->subevents}) {
    ok($se->trace->file ne $file, "subtest event is not in our file");
    ok($se->trace->line ne $line, "subtest event is not on our line");
    ok($se->facets->{assert}->{pass}, "subtest event passed");
}

done_testing;

# Make these tools appear to be in a different file/line
#line 100 'fake.pm'

sub my_tool_inherit {
    my $ctx = context();

    run_subtest(
        'foo',
        sub {
            ok(1, 'a');
            ok(2, 'b');
            is_deeply(\@_, [qw/arg1 arg2/], "got args");
        },
        {buffered => 1, inherit_trace => 1},
        'arg1', 'arg2'
    );

    $ctx->release;
}

sub my_tool_no_inherit {
    my $ctx = context();

    run_subtest(
        'foo',
        sub {
            ok(1, 'a');
            ok(2, 'b');
            is_deeply(\@_, [qw/arg1 arg2/], "got args");
        },
        {buffered => 1, inherit_trace => 0},
        'arg1', 'arg2'
    );

    $ctx->release;
}


PK     \‡3]€šƒ¼/	  /	    ipc_wait_timeout.tnu „[µü¤        use strict;
use warnings;

# The things done in this test can trigger a buggy return value on some
# platforms. This prevents that. The harness should catch actual failures. If
# no harness is active then we will NOT sanitize the exit value, false fails
# are better than false passes.
END { $? = 0 if $ENV{HARNESS_ACTIVE} }

# Some platforms throw a sigpipe in this test, we can ignore it.
BEGIN { $SIG{PIPE} = 'IGNORE' }

BEGIN { local ($@, $?, $!); eval { require threads } }
use Test2::Tools::Tiny;
use Test2::Util qw/CAN_THREAD CAN_REALLY_FORK/;
use Test2::IPC;
use Test2::API qw/test2_ipc_set_timeout test2_ipc_get_timeout/;

my $plan = 2;
$plan += 2 if CAN_REALLY_FORK;
$plan += 2 if CAN_THREAD && threads->can('is_joinable');
plan $plan;

is(test2_ipc_get_timeout(), 30, "got default timeout");
test2_ipc_set_timeout(10);
is(test2_ipc_get_timeout(), 10, "hanged the timeout");

if (CAN_REALLY_FORK) {
    note "Testing process waiting";
    my ($ppiper, $ppipew);
    pipe($ppiper, $ppipew) or die "Could not create pipe for fork";

    my $proc = fork();
    die "Could not fork!" unless defined $proc;

    unless ($proc) {
        local $SIG{ALRM} = sub { die "PROCESS TIMEOUT" };
        alarm 15;
        my $ignore = <$ppiper>;
        exit 0;
    }

    my $exit;
    my $warnings = warnings {
        $exit = Test2::API::Instance::_ipc_wait(1);
    };
    is($exit, 255, "Exited 255");
    like($warnings->[0], qr/Timeout waiting on child processes/, "Warned about timeout");
    print $ppipew "end\n";

    close($ppiper);
    close($ppipew);
}

if (CAN_THREAD) {
    note "Testing thread waiting";
    my ($tpiper, $tpipew);
    pipe($tpiper, $tpipew) or die "Could not create pipe for threads";

    my $thread = threads->create(
        sub {
            local $SIG{ALRM} = sub { die "THREAD TIMEOUT" };
            alarm 15;
            my $ignore = <$tpiper>;
        }
    );

    if ($thread->can('is_joinable')) {
        my $exit;
        my $warnings = warnings {
            $exit = Test2::API::Instance::_ipc_wait(1);
        };
        is($exit, 255, "Exited 255");
        like($warnings->[0], qr/Timeout waiting on child thread/, "Warned about timeout");
    }
    else {
        note "threads.pm is too old for a thread joining timeout :-(";
    }
    print $tpipew "end\n";

    close($tpiper);
    close($tpipew);
}
PK     \‡3]!
[  [    nested_context_exception.tnu „[µü¤        use strict;
use warnings;
BEGIN { $Test2::API::DO_DEPTH_CHECK = 1 }
use Test2::Tools::Tiny;

use Test2::API qw/context/;

skip_all("known to fail on $]") if $] le "5.006002";

sub outer {
    my $code = shift;
    my $ctx = context();

    $ctx->note("outer");

    my $out = eval { $code->() };

    $ctx->release;

    return $out;
}

sub dies {
    my $ctx = context();
    $ctx->note("dies");
    die "Foo";
}

sub bad_store {
    my $ctx = context();
    $ctx->note("bad store");
    return $ctx; # Emulate storing it somewhere
}

sub bad_simple {
    my $ctx = context();
    $ctx->note("bad simple");
    return;
}

my @warnings;
{
    local $SIG{__WARN__} = sub { push @warnings => @_ };
    eval { dies() };
}
ok(!@warnings, "no warnings") || diag @warnings;

@warnings = ();
my $keep = bad_store();
eval { my $x = 1 }; # Ensure an eval changing $@ does not meddle.
{
    local $SIG{__WARN__} = sub { push @warnings => @_ };
    ok(1, "random event");
}
ok(@warnings, "got warnings");
like(
    $warnings[0],
    qr/context\(\) was called to retrieve an existing context/,
    "got expected warning"
);
$keep = undef;

{
    @warnings = ();
    local $SIG{__WARN__} = sub { push @warnings => @_ };
    bad_simple();
}
ok(@warnings, "got warnings");
like(
    $warnings[0],
    qr/A context appears to have been destroyed without first calling release/,
    "got expected warning"
);

@warnings = ();
outer(\&dies);
{
    local $SIG{__WARN__} = sub { push @warnings => @_ };
    ok(1, "random event");
}
ok(!@warnings, "no warnings") || diag @warnings;


@warnings = ();
{
    local $SIG{__WARN__} = sub { push @warnings => @_ };
    outer(\&bad_store);
}
ok(@warnings, "got warnings");
like(
    $warnings[0],
    qr/A context appears to have been destroyed without first calling release/,
    "got expected warning"
);


{
    @warnings = ();
    local $SIG{__WARN__} = sub { push @warnings => @_ };
    outer(\&bad_simple);
}
ok(@warnings, "got warnings") || diag @warnings;
like(
    $warnings[0],
    qr/A context appears to have been destroyed without first calling release/,
    "got expected warning"
);


done_testing;
PK     \‡3]lã39c  c    Subtest_plan.tnu „[µü¤        use strict;
use warnings;

use Test2::Tools::Tiny;

use Test2::API qw/run_subtest intercept/;

my $events = intercept {
    my $code = sub { plan 4; ok(1) };
    run_subtest('bad_plan', $code, 'buffered');
};

is(
    $events->[-1]->message,
    "Bad subtest plan, expected 4 but ran 1",
    "Helpful message if subtest has a bad plan",
);

done_testing;
PK     \‡3]öTþM  M    init_croak.tnu „[µü¤        use strict;
use warnings;
use Test2::Tools::Tiny;

BEGIN {
    package Foo::Bar;
    use Test2::Util::HashBase qw/foo bar baz/;
    use Carp qw/croak/;

    sub init {
        my $self = shift;
        croak "'foo' is a required attribute"
            unless $self->{+FOO};
    }
}

skip_all("known to fail on $]") if $] le "5.006002";

$@ = "";
my ($file, $line) = (__FILE__, __LINE__ + 1);
eval { my $one = Foo::Bar->new };
my $err = $@;

like(
    $err,
    qr/^'foo' is a required attribute at \Q$file\E line $line/,
    "Croak does not report to HashBase from init"
);

done_testing;
PK     \‡3]ÑR2˜¹  ¹    Subtest_events.tnu „[µü¤        use strict;
use warnings;

use Test2::Tools::Tiny;

use Test2::API qw/run_subtest intercept/;

my $events = intercept {
    my $code = sub { ok(1) };
    run_subtest('blah', $code, 'buffered');
};

ok(!$events->[0]->trace->nested, "main event is not inside a subtest");
ok($events->[0]->subtest_id, "Got subtest id");
is($events->[0]->subevents->[0]->trace->hid, $events->[0]->subtest_id, "nested events are in the subtest");

done_testing;
PK     \‡3]ß‡5O      Formatter.tnu „[µü¤        use strict;
use warnings;

use Test2::Tools::Tiny;

use Test2::API qw/intercept run_subtest test2_stack/;
use Test2::Event::Bail;

{

	package Formatter::Subclass;
	use base 'Test2::Formatter';
	use Test2::Util::HashBase qw{f t};

    sub init {
        my $self = shift;
        $self->{+F} = [];
        $self->{+T} = [];
    }

	sub write         { }
	sub hide_buffered { 1 }

	sub terminate {
		my $s = shift;
		push @{$s->{+T}}, [@_];
	}

	sub finalize {
		my $s = shift;
		push @{$s->{+F}}, [@_];
	}
}

{
	my $f = Formatter::Subclass->new;
	intercept {
		my $hub = test2_stack->top;
		$hub->format($f);
		is(1, 1, 'test event 1');
		is(2, 2, 'test event 2');
		is(3, 2, 'test event 3');
		done_testing;
	};

	is(scalar @{$f->f}, 1, 'finalize method was called on formatter');
	is_deeply(
		$f->f->[0],
		[3, 3, 1, 0, 0],
		'finalize method received expected arguments'
	);

	ok(!@{$f->t}, 'terminate method was not called on formatter');
}

{
	my $f = Formatter::Subclass->new;

	intercept {
		my $hub = test2_stack->top;
		$hub->format($f);
		$hub->send(Test2::Event::Bail->new(reason => 'everything is terrible'));
		done_testing;
	};

	is(scalar @{$f->t}, 1, 'terminate method was called because of bail event');
	ok(!@{$f->f}, 'finalize method was not called on formatter');
}

{
	my $f = Formatter::Subclass->new;

	intercept {
		my $hub = test2_stack->top;
		$hub->format($f);
		$hub->send(Test2::Event::Plan->new(directive => 'skip_all', reason => 'Skipping all the tests'));
		done_testing;
	};

	is(scalar @{$f->t}, 1, 'terminate method was called because of plan skip_all event');
	ok(!@{$f->f}, 'finalize method was not called on formatter');
}

done_testing;
PK     \‡3]Œy±–      no_load_api.tnu „[µü¤        use strict;
use warnings;
use Data::Dumper;
# HARNESS-NO-STREAM
# HARNESS-NO-PRELOAD

###############################################################################
#                                                                             #
# This test is to insure certain objects do not load Test2::API directly or   #
# indirectly when being required. It is ok for import() to load Test2::API if #
# necessary, but simply requiring the modules should not.                     #
#                                                                             #
###############################################################################

require Test2::Formatter;
require Test2::Formatter::TAP;

require Test2::Event;
require Test2::Event::Bail;
require Test2::Event::Diag;
require Test2::Event::Exception;
require Test2::Event::Note;
require Test2::Event::Ok;
require Test2::Event::Plan;
require Test2::Event::Skip;
require Test2::Event::Subtest;
require Test2::Event::Waiting;

require Test2::Util;
require Test2::Util::ExternalMeta;
require Test2::Util::HashBase;
require Test2::EventFacet::Trace;

require Test2::Hub;
require Test2::Hub::Interceptor;
require Test2::Hub::Subtest;
require Test2::Hub::Interceptor::Terminator;

my @loaded = grep { $INC{$_} } qw{
    Test2/API.pm
    Test2/API/Instance.pm
    Test2/API/Context.pm
    Test2/API/Stack.pm
};

require Test2::Tools::Tiny;

Test2::Tools::Tiny::ok(!@loaded, "Test2::API was not loaded")
    || Test2::Tools::Tiny::diag("Loaded: " . Dumper(\@loaded));

Test2::Tools::Tiny::done_testing();
PK     \‡3]ÔÒ¢        disable_ipc_c.tnu „[µü¤        use strict;
use warnings;

use Test2::Tools::Tiny;
use Test2::API qw/test2_ipc_disable/;
BEGIN { test2_ipc_disable() }
use Test2::IPC::Driver::Files;

ok(Test2::API::test2_ipc_disabled, "disabled IPC");
ok(!Test2::API::test2_ipc, "No IPC");

done_testing;
PK     \‡3]–‹tš¤  ¤    Subtest_todo.tnu „[µü¤        use strict;
use warnings;

use Test2::Tools::Tiny;

use Test2::API qw/run_subtest intercept/;

my $events = intercept {
    todo 'testing todo', sub {
        run_subtest(
            'fails in todo',
            sub {
                ok(1, 'first passes');
                ok(0, 'second fails');
            }
        );
    };
};

ok($events->[1],                 'Test2::Event::Subtest', 'subtest ran');
ok($events->[1]->effective_pass, 'Test2::Event::Subtest', 'subtest effective_pass is true');
ok($events->[1]->todo,           'testing todo',          'subtest todo is set to expected value');

my $subevents = $events->[1]->subevents;

is(scalar @$subevents, 3, 'got subevents in the subtest');

ok($subevents->[0]->facets->{assert}->pass, 'first event passed');

ok(!$subevents->[1]->facets->{assert}->pass, 'second event failed');
ok(!$subevents->[1]->causes_fail,    'second event does not cause failure');

done_testing;
PK     \‡3]ÜKlVã  ã    trace_signature.tnu „[µü¤        use strict;
use warnings;

use Test2::Tools::Tiny;
use Test2::API qw/intercept context/;
use Test2::Util qw/get_tid/;

my $line;
my $events = intercept {
    $line = __LINE__ + 1;
    ok(1, "pass");
    sub {
        my $ctx = context;
        $ctx->pass;
        $ctx->pass;
        $ctx->release;
    }->();
};

my $sigpass = $events->[0]->trace->signature;
my $sigfail = $events->[1]->trace->signature;

ok($sigpass ne $sigfail, "Each tool got a new signature");

is($events->[$_]->trace->signature, $sigfail, "Diags share failed ok's signature") for 2 .. $#$events;

like($sigpass, qr/$$~${ \get_tid() }~\d+~\d+:$$:\Q${ \get_tid() }:${ \__FILE__ }:$line\E$/, "signature is sane");

my $trace = Test2::EventFacet::Trace->new(frame => ['main', 'foo.t', 42, 'xxx']);
delete $trace->{cid};
is($trace->signature, undef, "No signature without a cid");

is($events->[0]->related($events->[1]), 0, "event 0 is not related to event 1");
is($events->[1]->related($events->[2]), 1, "event 1 is related to event 2");

my $e = Test2::Event::Ok->new(pass => 1);
is($e->related($events->[0]), undef, "Cannot check relation, invalid trace");

$e = Test2::Event::Ok->new(pass => 1, trace => Test2::EventFacet::Trace->new(frame => ['', '', '', '']));
is($e->related($events->[0]), undef, "Cannot check relation, incomplete trace");

$e = Test2::Event::Ok->new(pass => 1, trace => Test2::EventFacet::Trace->new(frame => []));
is($e->related($events->[0]), undef, "Cannot check relation, incomplete trace");

done_testing;
PK       \‡3]¢›ã±   ±   	                err_var.tnu „[µü¤        PK       \‡3]äR‘]  ]              ê   intercept.tnu „[µü¤        PK       \‡3]Ê¡žÜ"  "              ‚  special_names.tnu „[µü¤        PK       \‡3]K½ÿx
  x
              ã
  Subtest_buffer_formatter.tnu „[µü¤        PK       \‡3]~¢¡uÊ  Ê              ¥  disable_ipc_d.tnu „[µü¤        PK       \‡3]ö;}wV  V              ®  uuid.tnu „[µü¤        PK       \‡3]Éç]×Ë   Ë               :%  disable_ipc_a.tnu „[µü¤        PK       \‡3]]3æŠ  Š              D&  Subtest_callback.tnu „[µü¤        PK       \‡3]÷$Âd  d              *  Taint.tnu „[µü¤        PK       \‡3]G<€ÞÛ   Û               «+  disable_ipc_b.tnu „[µü¤        PK       \‡3]cRCüž  ž              Å,  subtest_bailout.tnu „[µü¤        PK       \‡3]bföØ  Ø              ¤1  run_subtest_inherit.tnu „[µü¤        PK       \‡3]€šƒ¼/	  /	              Á:  ipc_wait_timeout.tnu „[µü¤        PK       \‡3]!
[  [              2D  nested_context_exception.tnu „[µü¤        PK       \‡3]lã39c  c              ×L  Subtest_plan.tnu „[µü¤        PK       \‡3]öTþM  M              xN  init_croak.tnu „[µü¤        PK       \‡3]ÑR2˜¹  ¹              Q  Subtest_events.tnu „[µü¤        PK       \‡3]ß‡5O                úR  Formatter.tnu „[µü¤        PK       \‡3]Œy±–                ÂY  no_load_api.tnu „[µü¤        PK       \‡3]ÔÒ¢                  `  disable_ipc_c.tnu „[µü¤        PK       \‡3]–‹tš¤  ¤              Wa  Subtest_todo.tnu „[µü¤        PK       \‡3]ÜKlVã  ã              9e  trace_signature.tnu „[µü¤        PK      Ë  ]k    