TAP/Version.pm000064400000003154000000000000007117 0ustar00package Test2::Event::TAP::Version; use strict; use warnings; our $VERSION = '1.302183'; use Carp qw/croak/; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) } use Test2::Util::HashBase qw/version/; sub init { my $self = shift; defined $self->{+VERSION} or croak "'version' is a required attribute"; } sub summary { 'TAP version ' . $_[0]->{+VERSION} } sub facet_data { my $self = shift; my $out = $self->common_facet_data; $out->{about}->{details} = $self->summary; push @{$out->{info}} => { tag => 'INFO', debug => 0, details => $self->summary, }; return $out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::TAP::Version - Event for TAP version. =head1 DESCRIPTION This event is used if a TAP formatter wishes to set a version. =head1 SYNOPSIS use Test2::API qw/context/; use Test2::Event::Encoding; my $ctx = context(); my $event = $ctx->send_event('TAP::Version', version => 42); =head1 METHODS Inherits from L. Also defines: =over 4 =item $version = $e->version The TAP version being parsed. =back =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Fail.pm000064400000003742000000000000005724 0ustar00package Test2::Event::Fail; use strict; use warnings; our $VERSION = '1.302183'; use Test2::EventFacet::Info; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event); *META_KEY = \&Test2::Util::ExternalMeta::META_KEY; } use Test2::Util::HashBase qw{ -name -info }; ############# # Old API sub summary { "fail" } sub increments_count { 1 } sub diagnostics { 0 } sub no_display { 0 } sub subtest_id { undef } sub terminate { () } sub global { () } sub sets_plan { () } sub causes_fail { my $self = shift; return 0 if $self->{+AMNESTY} && @{$self->{+AMNESTY}}; return 1; } ############# # New API sub add_info { my $self = shift; for my $in (@_) { $in = {%$in} if ref($in) ne 'ARRAY'; $in = Test2::EventFacet::Info->new($in); push @{$self->{+INFO}} => $in; } } sub facet_data { my $self = shift; my $out = $self->common_facet_data; $out->{about}->{details} = 'fail'; $out->{assert} = {pass => 0, details => $self->{+NAME}}; $out->{info} = [map {{ %{$_} }} @{$self->{+INFO}}] if $self->{+INFO}; return $out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Fail - Event for a simple failed assertion =head1 DESCRIPTION This is an optimal representation of a failed assertion. =head1 SYNOPSIS use Test2::API qw/context/; sub fail { my ($name) = @_; my $ctx = context(); $ctx->fail($name); $ctx->release; } =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Ok.pm000064400000006132000000000000005416 0ustar00package Test2::Event::Ok; use strict; use warnings; our $VERSION = '1.302183'; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) } use Test2::Util::HashBase qw{ pass effective_pass name todo }; sub init { my $self = shift; # Do not store objects here, only true or false $self->{+PASS} = $self->{+PASS} ? 1 : 0; $self->{+EFFECTIVE_PASS} = $self->{+PASS} || (defined($self->{+TODO}) ? 1 : 0); } { no warnings 'redefine'; sub set_todo { my $self = shift; my ($todo) = @_; $self->{+TODO} = $todo; $self->{+EFFECTIVE_PASS} = defined($todo) ? 1 : $self->{+PASS}; } } sub increments_count { 1 }; sub causes_fail { !$_[0]->{+EFFECTIVE_PASS} } sub summary { my $self = shift; my $name = $self->{+NAME} || "Nameless Assertion"; my $todo = $self->{+TODO}; if ($todo) { $name .= " (TODO: $todo)"; } elsif (defined $todo) { $name .= " (TODO)" } return $name; } sub extra_amnesty { my $self = shift; return unless defined($self->{+TODO}) || ($self->{+EFFECTIVE_PASS} && !$self->{+PASS}); return { tag => 'TODO', details => $self->{+TODO}, }; } sub facet_data { my $self = shift; my $out = $self->common_facet_data; $out->{assert} = { no_debug => 1, # Legacy behavior pass => $self->{+PASS}, details => $self->{+NAME}, }; if (my @exra_amnesty = $self->extra_amnesty) { my %seen; # It is possible the extra amnesty can be a duplicate, so filter it. $out->{amnesty} = [ grep { !$seen{defined($_->{tag}) ? $_->{tag} : ''}->{defined($_->{details}) ? $_->{details} : ''}++ } @exra_amnesty, @{$out->{amnesty}}, ]; } return $out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Ok - Ok event type =head1 DESCRIPTION Ok events are generated whenever you run a test that produces a result. Examples are C, and C. =head1 SYNOPSIS use Test2::API qw/context/; use Test2::Event::Ok; my $ctx = context(); my $event = $ctx->ok($bool, $name, \@diag); or: my $ctx = context(); my $event = $ctx->send_event( 'Ok', pass => $bool, name => $name, ); =head1 ACCESSORS =over 4 =item $rb = $e->pass The original true/false value of whatever was passed into the event (but reduced down to 1 or 0). =item $name = $e->name Name of the test. =item $b = $e->effective_pass This is the true/false value of the test after TODO and similar modifiers are taken into account. =back =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Diag.pm000064400000002657000000000000005721 0ustar00package Test2::Event::Diag; use strict; use warnings; our $VERSION = '1.302183'; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) } use Test2::Util::HashBase qw/message/; sub init { $_[0]->{+MESSAGE} = 'undef' unless defined $_[0]->{+MESSAGE}; } sub summary { $_[0]->{+MESSAGE} } sub diagnostics { 1 } sub facet_data { my $self = shift; my $out = $self->common_facet_data; $out->{info} = [ { tag => 'DIAG', debug => 1, details => $self->{+MESSAGE}, } ]; return $out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Diag - Diag event type =head1 DESCRIPTION Diagnostics messages, typically rendered to STDERR. =head1 SYNOPSIS use Test2::API qw/context/; use Test2::Event::Diag; my $ctx = context(); my $event = $ctx->diag($message); =head1 ACCESSORS =over 4 =item $diag->message The message for the diag. =back =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Waiting.pm000064400000002326000000000000006450 0ustar00package Test2::Event::Waiting; use strict; use warnings; our $VERSION = '1.302183'; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) } use Test2::Util::HashBase; sub global { 1 }; sub summary { "IPC is waiting for children to finish..." } sub facet_data { my $self = shift; my $out = $self->common_facet_data; push @{$out->{info}} => { tag => 'INFO', debug => 0, details => $self->summary, }; return $out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Waiting - Tell all procs/threads it is time to be done =head1 DESCRIPTION This event has no data of its own. This event is sent out by the IPC system when the main process/thread is ready to end. =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Note.pm000064400000002611000000000000005750 0ustar00package Test2::Event::Note; use strict; use warnings; our $VERSION = '1.302183'; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) } use Test2::Util::HashBase qw/message/; sub init { $_[0]->{+MESSAGE} = 'undef' unless defined $_[0]->{+MESSAGE}; } sub summary { $_[0]->{+MESSAGE} } sub facet_data { my $self = shift; my $out = $self->common_facet_data; $out->{info} = [ { tag => 'NOTE', debug => 0, details => $self->{+MESSAGE}, } ]; return $out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Note - Note event type =head1 DESCRIPTION Notes, typically rendered to STDOUT. =head1 SYNOPSIS use Test2::API qw/context/; use Test2::Event::Note; my $ctx = context(); my $event = $ctx->Note($message); =head1 ACCESSORS =over 4 =item $note->message The message for the note. =back =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Plan.pm000064400000006474000000000000005750 0ustar00package Test2::Event::Plan; use strict; use warnings; our $VERSION = '1.302183'; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) } use Test2::Util::HashBase qw{max directive reason}; use Carp qw/confess/; my %ALLOWED = ( 'SKIP' => 1, 'NO PLAN' => 1, ); sub init { if ($_[0]->{+DIRECTIVE}) { $_[0]->{+DIRECTIVE} = 'SKIP' if $_[0]->{+DIRECTIVE} eq 'skip_all'; $_[0]->{+DIRECTIVE} = 'NO PLAN' if $_[0]->{+DIRECTIVE} eq 'no_plan'; confess "'" . $_[0]->{+DIRECTIVE} . "' is not a valid plan directive" unless $ALLOWED{$_[0]->{+DIRECTIVE}}; } else { confess "Cannot have a reason without a directive!" if defined $_[0]->{+REASON}; confess "No number of tests specified" unless defined $_[0]->{+MAX}; confess "Plan test count '" . $_[0]->{+MAX} . "' does not appear to be a valid positive integer" unless $_[0]->{+MAX} =~ m/^\d+$/; $_[0]->{+DIRECTIVE} = ''; } } sub sets_plan { my $self = shift; return ( $self->{+MAX}, $self->{+DIRECTIVE}, $self->{+REASON}, ); } sub terminate { my $self = shift; # On skip_all we want to terminate the hub return 0 if $self->{+DIRECTIVE} && $self->{+DIRECTIVE} eq 'SKIP'; return undef; } sub summary { my $self = shift; my $max = $self->{+MAX}; my $directive = $self->{+DIRECTIVE}; my $reason = $self->{+REASON}; return "Plan is $max assertions" if $max || !$directive; return "Plan is '$directive', $reason" if $reason; return "Plan is '$directive'"; } sub facet_data { my $self = shift; my $out = $self->common_facet_data; $out->{control}->{terminate} = $self->{+DIRECTIVE} eq 'SKIP' ? 0 : undef unless defined $out->{control}->{terminate}; $out->{plan} = {count => $self->{+MAX}}; $out->{plan}->{details} = $self->{+REASON} if defined $self->{+REASON}; if (my $dir = $self->{+DIRECTIVE}) { $out->{plan}->{skip} = 1 if $dir eq 'SKIP'; $out->{plan}->{none} = 1 if $dir eq 'NO PLAN'; } return $out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Plan - The event of a plan =head1 DESCRIPTION Plan events are fired off whenever a plan is declared, done testing is called, or a subtext completes. =head1 SYNOPSIS use Test2::API qw/context/; use Test2::Event::Plan; my $ctx = context(); # Plan for 10 tests to run my $event = $ctx->plan(10); # Plan to skip all tests (will exit 0) $ctx->plan(0, skip_all => "These tests need to be skipped"); =head1 ACCESSORS =over 4 =item $num = $plan->max Get the number of expected tests =item $dir = $plan->directive Get the directive (such as TODO, skip_all, or no_plan). =item $reason = $plan->reason Get the reason for the directive. =back =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Pass.pm000064400000003616000000000000005757 0ustar00package Test2::Event::Pass; use strict; use warnings; our $VERSION = '1.302183'; use Test2::EventFacet::Info; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event); *META_KEY = \&Test2::Util::ExternalMeta::META_KEY; } use Test2::Util::HashBase qw{ -name -info }; ############## # Old API sub summary { "pass" } sub increments_count { 1 } sub causes_fail { 0 } sub diagnostics { 0 } sub no_display { 0 } sub subtest_id { undef } sub terminate { () } sub global { () } sub sets_plan { () } ############## # New API sub add_info { my $self = shift; for my $in (@_) { $in = {%$in} if ref($in) ne 'ARRAY'; $in = Test2::EventFacet::Info->new($in); push @{$self->{+INFO}} => $in; } } sub facet_data { my $self = shift; my $out = $self->common_facet_data; $out->{about}->{details} = 'pass'; $out->{assert} = {pass => 1, details => $self->{+NAME}}; $out->{info} = [map {{ %{$_} }} @{$self->{+INFO}}] if $self->{+INFO}; return $out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Pass - Event for a simple passing assertion =head1 DESCRIPTION This is an optimal representation of a passing assertion. =head1 SYNOPSIS use Test2::API qw/context/; sub pass { my ($name) = @_; my $ctx = context(); $ctx->pass($name); $ctx->release; } =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Skip.pm000064400000003732000000000000005756 0ustar00package Test2::Event::Skip; use strict; use warnings; our $VERSION = '1.302183'; BEGIN { require Test2::Event::Ok; our @ISA = qw(Test2::Event::Ok) } use Test2::Util::HashBase qw{reason}; sub init { my $self = shift; $self->SUPER::init; $self->{+EFFECTIVE_PASS} = 1; } sub causes_fail { 0 } sub summary { my $self = shift; my $out = $self->SUPER::summary(@_); if (my $reason = $self->reason) { $out .= " (SKIP: $reason)"; } else { $out .= " (SKIP)"; } return $out; } sub extra_amnesty { my $self = shift; my @out; push @out => { tag => 'TODO', details => $self->{+TODO}, } if defined $self->{+TODO}; push @out => { tag => 'skip', details => $self->{+REASON}, inherited => 0, }; return @out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Skip - Skip event type =head1 DESCRIPTION Skip events bump test counts just like L events, but they can never fail. =head1 SYNOPSIS use Test2::API qw/context/; use Test2::Event::Skip; my $ctx = context(); my $event = $ctx->skip($name, $reason); or: my $ctx = context(); my $event = $ctx->send_event( 'Skip', name => $name, reason => $reason, ); =head1 ACCESSORS =over 4 =item $reason = $e->reason The original true/false value of whatever was passed into the event (but reduced down to 1 or 0). =back =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Encoding.pm000064400000003351000000000000006573 0ustar00package Test2::Event::Encoding; use strict; use warnings; our $VERSION = '1.302183'; use Carp qw/croak/; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) } use Test2::Util::HashBase qw/encoding/; sub init { my $self = shift; defined $self->{+ENCODING} or croak "'encoding' is a required attribute"; } sub summary { 'Encoding set to ' . $_[0]->{+ENCODING} } sub facet_data { my $self = shift; my $out = $self->common_facet_data; $out->{control}->{encoding} = $self->{+ENCODING}; $out->{about}->{details} = $self->summary; return $out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Encoding - Set the encoding for the output stream =head1 DESCRIPTION The encoding event is generated when a test file wants to specify the encoding to be used when formatting its output. This event is intended to be produced by formatter classes and used for interpreting test names, message contents, etc. =head1 SYNOPSIS use Test2::API qw/context/; use Test2::Event::Encoding; my $ctx = context(); my $event = $ctx->send_event('Encoding', encoding => 'UTF-8'); =head1 METHODS Inherits from L. Also defines: =over 4 =item $encoding = $e->encoding The encoding being specified. =back =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Bail.pm000064400000003240000000000000005711 0ustar00package Test2::Event::Bail; use strict; use warnings; our $VERSION = '1.302183'; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) } use Test2::Util::HashBase qw{reason buffered}; # Make sure the tests terminate sub terminate { 255 }; sub global { 1 }; sub causes_fail { 1 } sub summary { my $self = shift; return "Bail out! " . $self->{+REASON} if $self->{+REASON}; return "Bail out!"; } sub diagnostics { 1 } sub facet_data { my $self = shift; my $out = $self->common_facet_data; $out->{control} = { global => 1, halt => 1, details => $self->{+REASON}, terminate => 255, }; return $out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Bail - Bailout! =head1 DESCRIPTION The bailout event is generated when things go horribly wrong and you need to halt all testing in the current file. =head1 SYNOPSIS use Test2::API qw/context/; use Test2::Event::Bail; my $ctx = context(); my $event = $ctx->bail('Stuff is broken'); =head1 METHODS Inherits from L. Also defines: =over 4 =item $reason = $e->reason The reason for the bailout. =back =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Exception.pm000064400000003365000000000000007010 0ustar00package Test2::Event::Exception; use strict; use warnings; our $VERSION = '1.302183'; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) } use Test2::Util::HashBase qw{error}; sub init { my $self = shift; $self->{+ERROR} = "$self->{+ERROR}"; } sub causes_fail { 1 } sub summary { my $self = shift; chomp(my $msg = "Exception: " . $self->{+ERROR}); return $msg; } sub diagnostics { 1 } sub facet_data { my $self = shift; my $out = $self->common_facet_data; $out->{errors} = [ { tag => 'ERROR', fail => 1, details => $self->{+ERROR}, } ]; return $out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Exception - Exception event =head1 DESCRIPTION An exception event will display to STDERR, and will prevent the overall test file from passing. =head1 SYNOPSIS use Test2::API qw/context/; use Test2::Event::Exception; my $ctx = context(); my $event = $ctx->send_event('Exception', error => 'Stuff is broken'); =head1 METHODS Inherits from L. Also defines: =over 4 =item $reason = $e->error The reason for the exception. =back =head1 CAVEATS Be aware that all exceptions are stringified during construction. =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Generic.pm000064400000013425000000000000006424 0ustar00package Test2::Event::Generic; use strict; use warnings; use Carp qw/croak/; use Scalar::Util qw/reftype/; our $VERSION = '1.302183'; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) } use Test2::Util::HashBase; my @FIELDS = qw{ causes_fail increments_count diagnostics no_display callback terminate global sets_plan summary facet_data }; my %DEFAULTS = ( causes_fail => 0, increments_count => 0, diagnostics => 0, no_display => 0, ); sub init { my $self = shift; for my $field (@FIELDS) { my $val = defined $self->{$field} ? delete $self->{$field} : $DEFAULTS{$field}; next unless defined $val; my $set = "set_$field"; $self->$set($val); } } for my $field (@FIELDS) { no strict 'refs'; *$field = sub { exists $_[0]->{$field} ? $_[0]->{$field} : () } unless exists &{$field}; *{"set_$field"} = sub { $_[0]->{$field} = $_[1] } unless exists &{"set_$field"}; } sub can { my $self = shift; my ($name) = @_; return $self->SUPER::can($name) unless $name eq 'callback'; return $self->{callback} || \&Test2::Event::callback; } sub facet_data { my $self = shift; return $self->{facet_data} || $self->SUPER::facet_data(); } sub summary { my $self = shift; return $self->{summary} if defined $self->{summary}; $self->SUPER::summary(); } sub sets_plan { my $self = shift; return unless $self->{sets_plan}; return @{$self->{sets_plan}}; } sub callback { my $self = shift; my $cb = $self->{callback} || return; $self->$cb(@_); } sub set_global { my $self = shift; my ($bool) = @_; if(!defined $bool) { delete $self->{global}; return undef; } $self->{global} = $bool; } sub set_callback { my $self = shift; my ($cb) = @_; if(!defined $cb) { delete $self->{callback}; return undef; } croak "callback must be a code reference" unless ref($cb) && reftype($cb) eq 'CODE'; $self->{callback} = $cb; } sub set_terminate { my $self = shift; my ($exit) = @_; if(!defined $exit) { delete $self->{terminate}; return undef; } croak "terminate must be a positive integer" unless $exit =~ m/^\d+$/; $self->{terminate} = $exit; } sub set_sets_plan { my $self = shift; my ($plan) = @_; if(!defined $plan) { delete $self->{sets_plan}; return undef; } croak "'sets_plan' must be an array reference" unless ref($plan) && reftype($plan) eq 'ARRAY'; $self->{sets_plan} = $plan; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Generic - Generic event type. =head1 DESCRIPTION This is a generic event that lets you customize all fields in the event API. This is useful if you have need for a custom event that does not make sense as a published reusable event subclass. =head1 SYNOPSIS use Test2::API qw/context/; sub send_custom_fail { my $ctx = shift; $ctx->send_event('Generic', causes_fail => 1, summary => 'The sky is falling'); $ctx->release; } send_custom_fail(); =head1 METHODS =over 4 =item $e->facet_data($data) =item $data = $e->facet_data Get or set the facet data (see L). If no facet_data is set then C<< Test2::Event->facet_data >> will be called to produce facets from the other data. =item $e->callback($hub) Call the custom callback if one is set, otherwise this does nothing. =item $e->set_callback(sub { ... }) Set the custom callback. The custom callback must be a coderef. The first argument to your callback will be the event itself, the second will be the L that is using the callback. =item $bool = $e->causes_fail =item $e->set_causes_fail($bool) Get/Set the C attribute. This defaults to C<0>. =item $bool = $e->diagnostics =item $e->set_diagnostics($bool) Get/Set the C attribute. This defaults to C<0>. =item $bool_or_undef = $e->global =item @bool_or_empty = $e->global =item $e->set_global($bool_or_undef) Get/Set the C attribute. This defaults to an empty list which is undef in scalar context. =item $bool = $e->increments_count =item $e->set_increments_count($bool) Get/Set the C attribute. This defaults to C<0>. =item $bool = $e->no_display =item $e->set_no_display($bool) Get/Set the C attribute. This defaults to C<0>. =item @plan = $e->sets_plan Get the plan if this event sets one. The plan is a list of up to 3 items: C<($count, $directive, $reason)>. C<$count> must be defined, the others may be undef, or may not exist at all. =item $e->set_sets_plan(\@plan) Set the plan. You must pass in an arrayref with up to 3 elements. =item $summary = $e->summary =item $e->set_summary($summary_or_undef) Get/Set the summary. This will default to the event package C<'Test2::Event::Generic'>. You can set it to any value. Setting this to C will reset it to the default. =item $int_or_undef = $e->terminate =item @int_or_empty = $e->terminate =item $e->set_terminate($int_or_undef) This will get/set the C attribute. This defaults to undef in scalar context, or an empty list in list context. Setting this to undef will clear it completely. This must be set to a positive integer (0 or larger). =back =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut Subtest.pm000064400000006175000000000000006505 0ustar00package Test2::Event::Subtest; use strict; use warnings; our $VERSION = '1.302183'; BEGIN { require Test2::Event::Ok; our @ISA = qw(Test2::Event::Ok) } use Test2::Util::HashBase qw{subevents buffered subtest_id subtest_uuid}; sub init { my $self = shift; $self->SUPER::init(); $self->{+SUBEVENTS} ||= []; if ($self->{+EFFECTIVE_PASS}) { $_->set_effective_pass(1) for grep { $_->can('effective_pass') } @{$self->{+SUBEVENTS}}; } } { no warnings 'redefine'; sub set_subevents { my $self = shift; my @subevents = @_; if ($self->{+EFFECTIVE_PASS}) { $_->set_effective_pass(1) for grep { $_->can('effective_pass') } @subevents; } $self->{+SUBEVENTS} = \@subevents; } sub set_effective_pass { my $self = shift; my ($pass) = @_; if ($pass) { $_->set_effective_pass(1) for grep { $_->can('effective_pass') } @{$self->{+SUBEVENTS}}; } elsif ($self->{+EFFECTIVE_PASS} && !$pass) { for my $s (grep { $_->can('effective_pass') } @{$self->{+SUBEVENTS}}) { $_->set_effective_pass(0) unless $s->can('todo') && defined $s->todo; } } $self->{+EFFECTIVE_PASS} = $pass; } } sub summary { my $self = shift; my $name = $self->{+NAME} || "Nameless Subtest"; my $todo = $self->{+TODO}; if ($todo) { $name .= " (TODO: $todo)"; } elsif (defined $todo) { $name .= " (TODO)"; } return $name; } sub facet_data { my $self = shift; my $out = $self->SUPER::facet_data(); $out->{parent} = { hid => $self->subtest_id, children => [map {$_->facet_data} @{$self->{+SUBEVENTS}}], buffered => $self->{+BUFFERED}, }; return $out; } sub add_amnesty { my $self = shift; for my $am (@_) { $am = {%$am} if ref($am) ne 'ARRAY'; $am = Test2::EventFacet::Amnesty->new($am); push @{$self->{+AMNESTY}} => $am; for my $e (@{$self->{+SUBEVENTS}}) { $e->add_amnesty($am->clone(inherited => 1)); } } } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::Subtest - Event for subtest types =head1 DESCRIPTION This class represents a subtest. This class is a subclass of L. =head1 ACCESSORS This class inherits from L. =over 4 =item $arrayref = $e->subevents Returns the arrayref containing all the events from the subtest =item $bool = $e->buffered True if the subtest is buffered, that is all subevents render at once. If this is false it means all subevents render as they are produced. =back =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut V2.pm000064400000011453000000000000005336 0ustar00package Test2::Event::V2; use strict; use warnings; our $VERSION = '1.302183'; use Scalar::Util qw/reftype/; use Carp qw/croak/; BEGIN { require Test2::Event; our @ISA = qw(Test2::Event) } use Test2::Util::Facets2Legacy qw{ causes_fail diagnostics global increments_count no_display sets_plan subtest_id summary terminate }; use Test2::Util::HashBase qw/-about/; sub non_facet_keys { return ( +UUID, Test2::Util::ExternalMeta::META_KEY(), ); } sub init { my $self = shift; my $uuid; if ($uuid = $self->{+UUID}) { croak "uuid '$uuid' passed to constructor, but uuid '$self->{+ABOUT}->{uuid}' is already set in the 'about' facet" if $self->{+ABOUT}->{uuid} && $self->{+ABOUT}->{uuid} ne $uuid; $self->{+ABOUT}->{uuid} = $uuid; } elsif ($self->{+ABOUT} && $self->{+ABOUT}->{uuid}) { $uuid = $self->{+ABOUT}->{uuid}; $self->SUPER::set_uuid($uuid); } # Clone the trace, make sure it is blessed if (my $trace = $self->{+TRACE}) { $self->{+TRACE} = Test2::EventFacet::Trace->new(%$trace); } } sub set_uuid { my $self = shift; my ($uuid) = @_; $self->{+ABOUT}->{uuid} = $uuid; $self->SUPER::set_uuid($uuid); } sub facet_data { my $self = shift; my $f = { %{$self} }; delete $f->{$_} for $self->non_facet_keys; my %out; for my $k (keys %$f) { next if substr($k, 0, 1) eq '_'; my $data = $f->{$k} or next; # Key is there, but no facet my $is_list = 'ARRAY' eq (reftype($data) || ''); $out{$k} = $is_list ? [ map { {%{$_}} } @$data ] : {%$data}; } if (my $meta = $self->meta_facet_data) { $out{meta} = {%$meta, %{$out{meta} || {}}}; } return \%out; } 1; __END__ =pod =encoding UTF-8 =head1 NAME Test2::Event::V2 - Second generation event. =head1 DESCRIPTION This is the event type that should be used instead of L or its legacy subclasses. =head1 SYNOPSIS =head2 USING A CONTEXT use Test2::API qw/context/; sub my_tool { my $ctx = context(); my $event = $ctx->send_ev2(info => [{tag => 'NOTE', details => "This is a note"}]); $ctx->release; return $event; } =head2 USING THE CONSTRUCTOR use Test2::Event::V2; my $e = Test2::Event::V2->new( trace => {frame => [$PKG, $FILE, $LINE, $SUBNAME]}, info => [{tag => 'NOTE', details => "This is a note"}], ); =head1 METHODS This class inherits from L. =over 4 =item $fd = $e->facet_data() This will return a hashref of facet data. Each facet hash will be a shallow copy of the original. =item $about = $e->about() This will return the 'about' facet hashref. B This will return the internal hashref, not a copy. =item $trace = $e->trace() This will return the 'trace' facet, normally blessed (but this is not enforced when the trace is set using C. B This will return the internal trace, not a copy. =back =head2 MUTATION =over 4 =item $e->add_amnesty({...}) Inherited from L. This can be used to add 'amnesty' facets to an existing event. Each new item is added to the B of the list. B Items B blessed when added. =item $e->add_hub({...}) Inherited from L. This is used by hubs to stamp events as they pass through. New items are added to the B of the list. B Items B blessed when added. =item $e->set_uuid($UUID) Inherited from L, overridden to also vivify/mutate the 'about' facet. =item $e->set_trace($trace) Inherited from L which allows you to change the trace. B This method does not bless/clone the trace for you. Many things will expect the trace to be blessed, so you should probably do that. =back =head2 LEGACY SUPPORT METHODS These are all imported from L, see that module or L for documentation on what they do. =over 4 =item causes_fail =item diagnostics =item global =item increments_count =item no_display =item sets_plan =item subtest_id =item summary =item terminate =back =head1 THIRD PARTY META-DATA This object consumes L which provides a consistent way for you to attach meta-data to instances of this class. This is useful for tools, plugins, and other extensions. =head1 SOURCE The source code repository for Test2 can be found at F. =head1 MAINTAINERS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 AUTHORS =over 4 =item Chad Granum Eexodist@cpan.orgE =back =head1 COPYRIGHT Copyright 2020 Chad Granum Eexodist@cpan.orgE. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F =cut FailedMessageEvent.php000077700000001375000000000000010726 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\Mailer\Event; use Symfony\Component\Mime\RawMessage; use Symfony\Contracts\EventDispatcher\Event; /** * @author Fabien Potencier */ final class FailedMessageEvent extends Event { public function __construct( private RawMessage $message, private \Throwable $error, ) { } public function getMessage(): RawMessage { return $this->message; } public function getError(): \Throwable { return $this->error; } } SentMessageEvent.php000077700000001175000000000000010451 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\Mailer\Event; use Symfony\Component\Mailer\SentMessage; use Symfony\Contracts\EventDispatcher\Event; /** * @author Fabien Potencier */ final class SentMessageEvent extends Event { public function __construct(private SentMessage $message) { } public function getMessage(): SentMessage { return $this->message; } } MessageEvent.php000077700000004735000000000000007624 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\Mailer\Event; use Symfony\Component\Mailer\Envelope; use Symfony\Component\Mailer\Exception\LogicException; use Symfony\Component\Messenger\Stamp\StampInterface; use Symfony\Component\Mime\RawMessage; use Symfony\Contracts\EventDispatcher\Event; /** * Allows the transformation of a Message and the Envelope before the email is sent. * * @author Fabien Potencier */ final class MessageEvent extends Event { private RawMessage $message; private Envelope $envelope; private string $transport; private bool $queued; private bool $rejected = false; /** @var StampInterface[] */ private array $stamps = []; public function __construct(RawMessage $message, Envelope $envelope, string $transport, bool $queued = false) { $this->message = $message; $this->envelope = $envelope; $this->transport = $transport; $this->queued = $queued; } public function getMessage(): RawMessage { return $this->message; } public function setMessage(RawMessage $message): void { $this->message = $message; } public function getEnvelope(): Envelope { return $this->envelope; } public function setEnvelope(Envelope $envelope): void { $this->envelope = $envelope; } public function getTransport(): string { return $this->transport; } public function isQueued(): bool { return $this->queued; } public function isRejected(): bool { return $this->rejected; } public function reject(): void { $this->rejected = true; $this->stopPropagation(); } public function addStamp(StampInterface $stamp): void { if (!$this->queued) { throw new LogicException(sprintf('Cannot call "%s()" on a message that is not meant to be queued.', __METHOD__)); } $this->stamps[] = $stamp; } /** * @return StampInterface[] */ public function getStamps(): array { if (!$this->queued) { throw new LogicException(sprintf('Cannot call "%s()" on a message that is not meant to be queued.', __METHOD__)); } return $this->stamps; } } MessageEvents.php000077700000002764000000000000010007 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\Mailer\Event; use Symfony\Component\Mime\RawMessage; /** * @author Fabien Potencier */ class MessageEvents { /** * @var MessageEvent[] */ private array $events = []; /** * @var array */ private array $transports = []; public function add(MessageEvent $event): void { $this->events[] = $event; $this->transports[$event->getTransport()] = true; } public function getTransports(): array { return array_keys($this->transports); } /** * @return MessageEvent[] */ public function getEvents(?string $name = null): array { if (null === $name) { return $this->events; } $events = []; foreach ($this->events as $event) { if ($name === $event->getTransport()) { $events[] = $event; } } return $events; } /** * @return RawMessage[] */ public function getMessages(?string $name = null): array { $events = $this->getEvents($name); $messages = []; foreach ($events as $event) { $messages[] = $event->getMessage(); } return $messages; } } ConsoleSignalEvent.php000075500000002634000000000000010770 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\Console\Event; use Symfony\Component\Console\Command\Command; use Symfony\Component\Console\Input\InputInterface; use Symfony\Component\Console\Output\OutputInterface; /** * @author marie */ final class ConsoleSignalEvent extends ConsoleEvent { private int $handlingSignal; private int|false $exitCode; public function __construct(Command $command, InputInterface $input, OutputInterface $output, int $handlingSignal, int|false $exitCode = 0) { parent::__construct($command, $input, $output); $this->handlingSignal = $handlingSignal; $this->exitCode = $exitCode; } public function getHandlingSignal(): int { return $this->handlingSignal; } public function setExitCode(int $exitCode): void { if ($exitCode < 0 || $exitCode > 255) { throw new \InvalidArgumentException('Exit code must be between 0 and 255.'); } $this->exitCode = $exitCode; } public function abortExit(): void { $this->exitCode = false; } public function getExitCode(): int|false { return $this->exitCode; } } ConsoleCommandEvent.php000075500000002456000000000000011133 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\Console\Event; /** * Allows to do things before the command is executed, like skipping the command or executing code before the command is * going to be executed. * * Changing the input arguments will have no effect. * * @author Fabien Potencier */ final class ConsoleCommandEvent extends ConsoleEvent { /** * The return code for skipped commands, this will also be passed into the terminate event. */ public const RETURN_CODE_DISABLED = 113; /** * Indicates if the command should be run or skipped. */ private bool $commandShouldRun = true; /** * Disables the command, so it won't be run. */ public function disableCommand(): bool { return $this->commandShouldRun = false; } public function enableCommand(): bool { return $this->commandShouldRun = true; } /** * Returns true if the command is runnable, false otherwise. */ public function commandShouldRun(): bool { return $this->commandShouldRun; } } ConsoleAlarmEvent.php000066400000002176000000000000010607 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\Console\Event; use Symfony\Component\Console\Command\Command; use Symfony\Component\Console\Input\InputInterface; use Symfony\Component\Console\Output\OutputInterface; final class ConsoleAlarmEvent extends ConsoleEvent { public function __construct( Command $command, InputInterface $input, OutputInterface $output, private int|false $exitCode = 0, ) { parent::__construct($command, $input, $output); } public function setExitCode(int $exitCode): void { if ($exitCode < 0 || $exitCode > 255) { throw new \InvalidArgumentException('Exit code must be between 0 and 255.'); } $this->exitCode = $exitCode; } public function abortExit(): void { $this->exitCode = false; } public function getExitCode(): int|false { return $this->exitCode; } } ConsoleTerminateEvent.php000075500000002335000000000000011501 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\Console\Event; use Symfony\Component\Console\Command\Command; use Symfony\Component\Console\Input\InputInterface; use Symfony\Component\Console\Output\OutputInterface; /** * Allows to manipulate the exit code of a command after its execution. * * @author Francesco Levorato * @author Jules Pietri */ final class ConsoleTerminateEvent extends ConsoleEvent { public function __construct( Command $command, InputInterface $input, OutputInterface $output, private int $exitCode, private readonly ?int $interruptingSignal = null, ) { parent::__construct($command, $input, $output); } public function setExitCode(int $exitCode): void { $this->exitCode = $exitCode; } public function getExitCode(): int { return $this->exitCode; } public function getInterruptingSignal(): ?int { return $this->interruptingSignal; } } ConsoleEvent.php000075500000002520000000000000007624 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\Console\Event; use Symfony\Component\Console\Command\Command; use Symfony\Component\Console\Input\InputInterface; use Symfony\Component\Console\Output\OutputInterface; use Symfony\Contracts\EventDispatcher\Event; /** * Allows to inspect input and output of a command. * * @author Francesco Levorato */ class ConsoleEvent extends Event { protected $command; private InputInterface $input; private OutputInterface $output; public function __construct(?Command $command, InputInterface $input, OutputInterface $output) { $this->command = $command; $this->input = $input; $this->output = $output; } /** * Gets the command that is executed. */ public function getCommand(): ?Command { return $this->command; } /** * Gets the input instance. */ public function getInput(): InputInterface { return $this->input; } /** * Gets the output instance. */ public function getOutput(): OutputInterface { return $this->output; } } ConsoleErrorEvent.php000075500000002710000000000000010637 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\Console\Event; use Symfony\Component\Console\Command\Command; use Symfony\Component\Console\Input\InputInterface; use Symfony\Component\Console\Output\OutputInterface; /** * Allows to handle throwables thrown while running a command. * * @author Wouter de Jong */ final class ConsoleErrorEvent extends ConsoleEvent { private \Throwable $error; private int $exitCode; public function __construct(InputInterface $input, OutputInterface $output, \Throwable $error, ?Command $command = null) { parent::__construct($command, $input, $output); $this->error = $error; } public function getError(): \Throwable { return $this->error; } public function setError(\Throwable $error): void { $this->error = $error; } public function setExitCode(int $exitCode): void { $this->exitCode = $exitCode; $r = new \ReflectionProperty($this->error, 'code'); $r->setValue($this->error, $this->exitCode); } public function getExitCode(): int { return $this->exitCode ?? (\is_int($this->error->getCode()) && 0 !== $this->error->getCode() ? $this->error->getCode() : 1); } } Value/ClassMethod.php000077500000002234000000000000010506 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class ClassMethod { /** * @psalm-var class-string */ private readonly string $className; /** * @psalm-var non-empty-string */ private readonly string $methodName; /** * @psalm-param class-string $className * @psalm-param non-empty-string $methodName */ public function __construct(string $className, string $methodName) { $this->className = $className; $this->methodName = $methodName; } /** * @psalm-return class-string */ public function className(): string { return $this->className; } /** * @psalm-return non-empty-string */ public function methodName(): string { return $this->methodName; } } Value/ComparisonFailureBuilder.php000077500000003360000000000000013232 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; use function is_bool; use function is_scalar; use function print_r; use PHPUnit\Framework\ExpectationFailedException; use Throwable; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class ComparisonFailureBuilder { public static function from(Throwable $t): ?ComparisonFailure { if (!$t instanceof ExpectationFailedException) { return null; } if (!$t->getComparisonFailure()) { return null; } $expectedAsString = $t->getComparisonFailure()->getExpectedAsString(); if (empty($expectedAsString)) { $expectedAsString = self::mapScalarValueToString($t->getComparisonFailure()->getExpected()); } $actualAsString = $t->getComparisonFailure()->getActualAsString(); if (empty($actualAsString)) { $actualAsString = self::mapScalarValueToString($t->getComparisonFailure()->getActual()); } return new ComparisonFailure( $expectedAsString, $actualAsString, $t->getComparisonFailure()->getDiff(), ); } private static function mapScalarValueToString(mixed $value): string { if ($value === null) { return 'null'; } if (is_bool($value)) { return $value ? 'true' : 'false'; } if (is_scalar($value)) { return print_r($value, true); } return ''; } } Value/Test/TestMethod.php000077500000007067000000000000011310 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; use function assert; use function is_int; use function sprintf; use PHPUnit\Event\TestData\TestDataCollection; use PHPUnit\Metadata\MetadataCollection; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestMethod extends Test { /** * @psalm-var class-string */ private readonly string $className; /** * @psalm-var non-empty-string */ private readonly string $methodName; /** * @psalm-var non-negative-int */ private readonly int $line; private readonly TestDox $testDox; private readonly MetadataCollection $metadata; private readonly TestDataCollection $testData; /** * @psalm-param class-string $className * @psalm-param non-empty-string $methodName * @psalm-param non-empty-string $file * @psalm-param non-negative-int $line */ public function __construct(string $className, string $methodName, string $file, int $line, TestDox $testDox, MetadataCollection $metadata, TestDataCollection $testData) { parent::__construct($file); $this->className = $className; $this->methodName = $methodName; $this->line = $line; $this->testDox = $testDox; $this->metadata = $metadata; $this->testData = $testData; } /** * @psalm-return class-string */ public function className(): string { return $this->className; } /** * @psalm-return non-empty-string */ public function methodName(): string { return $this->methodName; } /** * @psalm-return non-negative-int */ public function line(): int { return $this->line; } public function testDox(): TestDox { return $this->testDox; } public function metadata(): MetadataCollection { return $this->metadata; } public function testData(): TestDataCollection { return $this->testData; } /** * @psalm-assert-if-true TestMethod $this */ public function isTestMethod(): bool { return true; } /** * @psalm-return non-empty-string */ public function id(): string { $buffer = $this->className . '::' . $this->methodName; if ($this->testData()->hasDataFromDataProvider()) { $buffer .= '#' . $this->testData->dataFromDataProvider()->dataSetName(); } return $buffer; } /** * @psalm-return non-empty-string */ public function nameWithClass(): string { return $this->className . '::' . $this->name(); } /** * @psalm-return non-empty-string */ public function name(): string { if (!$this->testData->hasDataFromDataProvider()) { return $this->methodName; } $dataSetName = $this->testData->dataFromDataProvider()->dataSetName(); if (is_int($dataSetName)) { $dataSetName = sprintf( ' with data set #%d', $dataSetName, ); } else { $dataSetName = sprintf( ' with data set "%s"', $dataSetName, ); } return $this->methodName . $dataSetName; } } Value/Test/Issue/SelfTrigger.php000064400000001361000000000000012517 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code\IssueTrigger; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class SelfTrigger extends IssueTrigger { /** * Your own code triggers an issue in your own code. */ public function isSelf(): true { return true; } public function asString(): string { return 'issue triggered by first-party code calling into first-party code'; } } Value/Test/Issue/IssueTrigger.php000064400000003742000000000000012723 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code\IssueTrigger; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ abstract class IssueTrigger { public static function test(): TestTrigger { return new TestTrigger; } public static function self(): SelfTrigger { return new SelfTrigger; } public static function direct(): DirectTrigger { return new DirectTrigger; } public static function indirect(): IndirectTrigger { return new IndirectTrigger; } public static function unknown(): UnknownTrigger { return new UnknownTrigger; } final private function __construct() { } /** * Your test code triggers an issue. * * @phpstan-assert-if-true TestTrigger $this */ public function isTest(): bool { return false; } /** * Your own code triggers an issue in your own code. * * @phpstan-assert-if-true SelfTrigger $this */ public function isSelf(): bool { return false; } /** * Your own code triggers an issue in third-party code. * * @phpstan-assert-if-true DirectTrigger $this */ public function isDirect(): bool { return false; } /** * Third-party code triggers an issue either in your own code or in third-party code. * * @phpstan-assert-if-true IndirectTrigger $this */ public function isIndirect(): bool { return false; } /** * @phpstan-assert-if-true UnknownTrigger $this */ public function isUnknown(): bool { return false; } abstract public function asString(): string; } Value/Test/Issue/IndirectTrigger.php000064400000001374000000000000013373 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code\IssueTrigger; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class IndirectTrigger extends IssueTrigger { /** * Third-party code triggers an issue either in your own code or in third-party code. */ public function isIndirect(): true { return true; } public function asString(): string { return 'issue triggered by third-party code'; } } Value/Test/Issue/DirectTrigger.php000064400000001370000000000000013040 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code\IssueTrigger; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class DirectTrigger extends IssueTrigger { /** * Your own code triggers an issue in third-party code. */ public function isDirect(): true { return true; } public function asString(): string { return 'issue triggered by first-party code calling into third-party code'; } } Value/Test/Issue/UnknownTrigger.php000064400000001263000000000000013266 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code\IssueTrigger; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class UnknownTrigger extends IssueTrigger { public function isUnknown(): true { return true; } public function asString(): string { return 'unknown if issue was triggered in first-party code or third-party code'; } } Value/Test/TestDox.php000077500000002444000000000000010614 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestDox { private readonly string $prettifiedClassName; private readonly string $prettifiedMethodName; private readonly string $prettifiedAndColorizedMethodName; public function __construct(string $prettifiedClassName, string $prettifiedMethodName, string $prettifiedAndColorizedMethodName) { $this->prettifiedClassName = $prettifiedClassName; $this->prettifiedMethodName = $prettifiedMethodName; $this->prettifiedAndColorizedMethodName = $prettifiedAndColorizedMethodName; } public function prettifiedClassName(): string { return $this->prettifiedClassName; } public function prettifiedMethodName(bool $colorize = false): string { if ($colorize) { return $this->prettifiedAndColorizedMethodName; } return $this->prettifiedMethodName; } } Value/Test/TestCollection.php000077500000002365000000000000012157 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; use function count; use Countable; use IteratorAggregate; /** * @template-implements IteratorAggregate * * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestCollection implements Countable, IteratorAggregate { /** * @psalm-var list */ private readonly array $tests; /** * @psalm-param list $tests */ public static function fromArray(array $tests): self { return new self(...$tests); } private function __construct(Test ...$tests) { $this->tests = $tests; } /** * @psalm-return list */ public function asArray(): array { return $this->tests; } public function count(): int { return count($this->tests); } public function getIterator(): TestCollectionIterator { return new TestCollectionIterator($this); } } Value/Test/TestCollectionIterator.php000077500000002235000000000000013665 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; use function count; use Iterator; /** * @template-implements Iterator * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestCollectionIterator implements Iterator { /** * @psalm-var list */ private readonly array $tests; private int $position = 0; public function __construct(TestCollection $tests) { $this->tests = $tests->asArray(); } public function rewind(): void { $this->position = 0; } public function valid(): bool { return $this->position < count($this->tests); } public function key(): int { return $this->position; } public function current(): Test { return $this->tests[$this->position]; } public function next(): void { $this->position++; } } Value/Test/TestMethodBuilder.php000077500000005774000000000000012622 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; use const DEBUG_BACKTRACE_IGNORE_ARGS; use const DEBUG_BACKTRACE_PROVIDE_OBJECT; use function assert; use function debug_backtrace; use function is_numeric; use PHPUnit\Event\Facade as EventFacade; use PHPUnit\Event\TestData\DataFromDataProvider; use PHPUnit\Event\TestData\DataFromTestDependency; use PHPUnit\Event\TestData\MoreThanOneDataSetFromDataProviderException; use PHPUnit\Event\TestData\TestDataCollection; use PHPUnit\Framework\TestCase; use PHPUnit\Metadata\Parser\Registry as MetadataRegistry; use PHPUnit\Util\Exporter; use PHPUnit\Util\Reflection; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class TestMethodBuilder { /** * @throws MoreThanOneDataSetFromDataProviderException */ public static function fromTestCase(TestCase $testCase): TestMethod { $methodName = $testCase->name(); assert(!empty($methodName)); $location = Reflection::sourceLocationFor($testCase::class, $methodName); return new TestMethod( $testCase::class, $methodName, $location['file'], $location['line'], TestDoxBuilder::fromTestCase($testCase), MetadataRegistry::parser()->forClassAndMethod($testCase::class, $methodName), self::dataFor($testCase), ); } /** * @throws NoTestCaseObjectOnCallStackException */ public static function fromCallStack(): TestMethod { foreach (debug_backtrace(DEBUG_BACKTRACE_PROVIDE_OBJECT | DEBUG_BACKTRACE_IGNORE_ARGS) as $frame) { if (isset($frame['object']) && $frame['object'] instanceof TestCase) { return $frame['object']->valueObjectForEvents(); } } throw new NoTestCaseObjectOnCallStackException; } /** * @throws MoreThanOneDataSetFromDataProviderException */ private static function dataFor(TestCase $testCase): TestDataCollection { $testData = []; if ($testCase->usesDataProvider()) { $dataSetName = $testCase->dataName(); if (is_numeric($dataSetName)) { $dataSetName = (int) $dataSetName; } $testData[] = DataFromDataProvider::from( $dataSetName, Exporter::export($testCase->providedData(), EventFacade::emitter()->exportsObjects()), $testCase->dataSetAsStringWithData(), ); } if ($testCase->hasDependencyInput()) { $testData[] = DataFromTestDependency::from( Exporter::export($testCase->dependencyInput(), EventFacade::emitter()->exportsObjects()), ); } return TestDataCollection::fromArray($testData); } } Value/Test/TestData/DataFromDataProvider.php000077500000003027000000000000014733 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestData; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class DataFromDataProvider extends TestData { private readonly int|string $dataSetName; private readonly string $dataAsStringForResultOutput; public static function from(int|string $dataSetName, string $data, string $dataAsStringForResultOutput): self { return new self($dataSetName, $data, $dataAsStringForResultOutput); } protected function __construct(int|string $dataSetName, string $data, string $dataAsStringForResultOutput) { $this->dataSetName = $dataSetName; $this->dataAsStringForResultOutput = $dataAsStringForResultOutput; parent::__construct($data); } public function dataSetName(): int|string { return $this->dataSetName; } /** * @internal This method is not covered by the backward compatibility promise for PHPUnit */ public function dataAsStringForResultOutput(): string { return $this->dataAsStringForResultOutput; } /** * @psalm-assert-if-true DataFromDataProvider $this */ public function isFromDataProvider(): bool { return true; } } Value/Test/TestData/TestDataCollectionIterator.php000077500000002257000000000000016174 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestData; use function count; use Iterator; /** * @template-implements Iterator * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestDataCollectionIterator implements Iterator { /** * @psalm-var list */ private readonly array $data; private int $position = 0; public function __construct(TestDataCollection $data) { $this->data = $data->asArray(); } public function rewind(): void { $this->position = 0; } public function valid(): bool { return $this->position < count($this->data); } public function key(): int { return $this->position; } public function current(): TestData { return $this->data[$this->position]; } public function next(): void { $this->position++; } } Value/Test/TestData/TestDataCollection.php000077500000004771000000000000014465 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestData; use function count; use Countable; use IteratorAggregate; /** * @template-implements IteratorAggregate * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestDataCollection implements Countable, IteratorAggregate { /** * @psalm-var list */ private readonly array $data; private ?DataFromDataProvider $fromDataProvider = null; /** * @psalm-param list $data * * @throws MoreThanOneDataSetFromDataProviderException */ public static function fromArray(array $data): self { return new self(...$data); } /** * @throws MoreThanOneDataSetFromDataProviderException */ private function __construct(TestData ...$data) { $this->ensureNoMoreThanOneDataFromDataProvider($data); $this->data = $data; } /** * @psalm-return list */ public function asArray(): array { return $this->data; } public function count(): int { return count($this->data); } /** * @psalm-assert-if-true !null $this->fromDataProvider */ public function hasDataFromDataProvider(): bool { return $this->fromDataProvider !== null; } /** * @throws NoDataSetFromDataProviderException */ public function dataFromDataProvider(): DataFromDataProvider { if (!$this->hasDataFromDataProvider()) { throw new NoDataSetFromDataProviderException; } return $this->fromDataProvider; } public function getIterator(): TestDataCollectionIterator { return new TestDataCollectionIterator($this); } /** * @psalm-param list $data * * @throws MoreThanOneDataSetFromDataProviderException */ private function ensureNoMoreThanOneDataFromDataProvider(array $data): void { foreach ($data as $_data) { if ($_data->isFromDataProvider()) { if ($this->fromDataProvider !== null) { throw new MoreThanOneDataSetFromDataProviderException; } $this->fromDataProvider = $_data; } } } } Value/Test/TestData/DataFromTestDependency.php000077500000001335000000000000015265 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestData; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class DataFromTestDependency extends TestData { public static function from(string $data): self { return new self($data); } /** * @psalm-assert-if-true DataFromTestDependency $this */ public function isFromTestDependency(): bool { return true; } } Value/Test/TestData/TestData.php000077500000001706000000000000012444 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestData; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ abstract class TestData { private readonly string $data; protected function __construct(string $data) { $this->data = $data; } public function data(): string { return $this->data; } /** * @psalm-assert-if-true DataFromDataProvider $this */ public function isFromDataProvider(): bool { return false; } /** * @psalm-assert-if-true DataFromTestDependency $this */ public function isFromTestDependency(): bool { return false; } } Value/Test/TestDoxBuilder.php000077500000002741000000000000012123 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; use PHPUnit\Event\TestData\MoreThanOneDataSetFromDataProviderException; use PHPUnit\Framework\TestCase; use PHPUnit\Logging\TestDox\NamePrettifier; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class TestDoxBuilder { /** * @throws MoreThanOneDataSetFromDataProviderException */ public static function fromTestCase(TestCase $testCase): TestDox { $prettifier = new NamePrettifier; return new TestDox( $prettifier->prettifyTestClassName($testCase::class), $prettifier->prettifyTestCase($testCase, false), $prettifier->prettifyTestCase($testCase, true), ); } /** * @psalm-param class-string $className * @psalm-param non-empty-string $methodName */ public static function fromClassNameAndMethodName(string $className, string $methodName): TestDox { $prettifier = new NamePrettifier; $prettifiedMethodName = $prettifier->prettifyTestMethodName($methodName); return new TestDox( $prettifier->prettifyTestClassName($className), $prettifiedMethodName, $prettifiedMethodName, ); } } Value/Test/Phpt.php000077500000001510000000000000010126 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Phpt extends Test { /** * @psalm-assert-if-true Phpt $this */ public function isPhpt(): bool { return true; } /** * @psalm-return non-empty-string */ public function id(): string { return $this->file(); } /** * @psalm-return non-empty-string */ public function name(): string { return $this->file(); } } Value/Test/Test.php000077500000002365000000000000010143 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ abstract class Test { /** * @psalm-var non-empty-string */ private readonly string $file; /** * @psalm-param non-empty-string $file */ public function __construct(string $file) { $this->file = $file; } /** * @psalm-return non-empty-string */ public function file(): string { return $this->file; } /** * @psalm-assert-if-true TestMethod $this */ public function isTestMethod(): bool { return false; } /** * @psalm-assert-if-true Phpt $this */ public function isPhpt(): bool { return false; } /** * @psalm-return non-empty-string */ abstract public function id(): string; /** * @psalm-return non-empty-string */ abstract public function name(): string; } Value/ThrowableBuilder.php000077500000002053000000000000011535 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; use PHPUnit\Event\NoPreviousThrowableException; use PHPUnit\Framework\Exception; use PHPUnit\Util\Filter; use PHPUnit\Util\ThrowableToStringMapper; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class ThrowableBuilder { /** * @throws Exception * @throws NoPreviousThrowableException */ public static function from(\Throwable $t): Throwable { $previous = $t->getPrevious(); if ($previous !== null) { $previous = self::from($previous); } return new Throwable( $t::class, $t->getMessage(), ThrowableToStringMapper::map($t), Filter::getFilteredStacktrace($t, false), $previous, ); } } Value/Runtime/PHPUnit.php000077500000001563000000000000011216 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Runtime; use PHPUnit\Runner\Version; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PHPUnit { private readonly string $versionId; private readonly string $releaseSeries; public function __construct() { $this->versionId = Version::id(); $this->releaseSeries = Version::series(); } public function versionId(): string { return $this->versionId; } public function releaseSeries(): string { return $this->releaseSeries; } } Value/Runtime/OperatingSystem.php000077500000001671000000000000013064 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Runtime; use const PHP_OS; use const PHP_OS_FAMILY; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class OperatingSystem { private readonly string $operatingSystem; private readonly string $operatingSystemFamily; public function __construct() { $this->operatingSystem = PHP_OS; $this->operatingSystemFamily = PHP_OS_FAMILY; } public function operatingSystem(): string { return $this->operatingSystem; } public function operatingSystemFamily(): string { return $this->operatingSystemFamily; } } Value/Runtime/Runtime.php000077500000002527000000000000011353 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Runtime; use function sprintf; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Runtime { private readonly OperatingSystem $operatingSystem; private readonly PHP $php; private readonly PHPUnit $phpunit; public function __construct() { $this->operatingSystem = new OperatingSystem; $this->php = new PHP; $this->phpunit = new PHPUnit; } public function asString(): string { $php = $this->php(); return sprintf( 'PHPUnit %s using PHP %s (%s) on %s', $this->phpunit()->versionId(), $php->version(), $php->sapi(), $this->operatingSystem()->operatingSystem(), ); } public function operatingSystem(): OperatingSystem { return $this->operatingSystem; } public function php(): PHP { return $this->php; } public function phpunit(): PHPUnit { return $this->phpunit; } } Value/Runtime/PHP.php000077500000004537000000000000010362 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Runtime; use const PHP_EXTRA_VERSION; use const PHP_MAJOR_VERSION; use const PHP_MINOR_VERSION; use const PHP_RELEASE_VERSION; use const PHP_SAPI; use const PHP_VERSION; use const PHP_VERSION_ID; use function array_merge; use function get_loaded_extensions; use function sort; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PHP { private readonly string $version; private readonly int $versionId; private readonly int $majorVersion; private readonly int $minorVersion; private readonly int $releaseVersion; private readonly string $extraVersion; private readonly string $sapi; /** * @psalm-var list */ private readonly array $extensions; public function __construct() { $this->version = PHP_VERSION; $this->versionId = PHP_VERSION_ID; $this->majorVersion = PHP_MAJOR_VERSION; $this->minorVersion = PHP_MINOR_VERSION; $this->releaseVersion = PHP_RELEASE_VERSION; $this->extraVersion = PHP_EXTRA_VERSION; $this->sapi = PHP_SAPI; $extensions = array_merge( get_loaded_extensions(true), get_loaded_extensions(), ); sort($extensions); $this->extensions = $extensions; } public function version(): string { return $this->version; } public function sapi(): string { return $this->sapi; } public function majorVersion(): int { return $this->majorVersion; } public function minorVersion(): int { return $this->minorVersion; } public function releaseVersion(): int { return $this->releaseVersion; } public function extraVersion(): string { return $this->extraVersion; } public function versionId(): int { return $this->versionId; } /** * @psalm-return list */ public function extensions(): array { return $this->extensions; } } Value/TestSuite/TestSuiteForTestMethodWithDataProvider.php000077500000003564000000000000020002 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use PHPUnit\Event\Code\TestCollection; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestSuiteForTestMethodWithDataProvider extends TestSuite { /** * @psalm-var class-string */ private readonly string $className; /** * @psalm-var non-empty-string */ private readonly string $methodName; private readonly string $file; private readonly int $line; /** * @psalm-param non-empty-string $name * @psalm-param class-string $className * @psalm-param non-empty-string $methodName */ public function __construct(string $name, int $size, TestCollection $tests, string $className, string $methodName, string $file, int $line) { parent::__construct($name, $size, $tests); $this->className = $className; $this->methodName = $methodName; $this->file = $file; $this->line = $line; } /** * @psalm-return class-string */ public function className(): string { return $this->className; } /** * @psalm-return non-empty-string */ public function methodName(): string { return $this->methodName; } public function file(): string { return $this->file; } public function line(): int { return $this->line; } /** * @psalm-assert-if-true TestSuiteForTestMethodWithDataProvider $this */ public function isForTestMethodWithDataProvider(): bool { return true; } } Value/TestSuite/TestSuite.php000077500000003206000000000000012162 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use PHPUnit\Event\Code\TestCollection; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ abstract class TestSuite { /** * @psalm-var non-empty-string */ private readonly string $name; private readonly int $count; private readonly TestCollection $tests; /** * @psalm-param non-empty-string $name */ public function __construct(string $name, int $size, TestCollection $tests) { $this->name = $name; $this->count = $size; $this->tests = $tests; } /** * @psalm-return non-empty-string */ public function name(): string { return $this->name; } public function count(): int { return $this->count; } public function tests(): TestCollection { return $this->tests; } /** * @psalm-assert-if-true TestSuiteWithName $this */ public function isWithName(): bool { return false; } /** * @psalm-assert-if-true TestSuiteForTestClass $this */ public function isForTestClass(): bool { return false; } /** * @psalm-assert-if-true TestSuiteForTestMethodWithDataProvider $this */ public function isForTestMethodWithDataProvider(): bool { return false; } } Value/TestSuite/TestSuiteBuilder.php000077500000006376000000000000013504 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use function explode; use PHPUnit\Event\Code\Test; use PHPUnit\Event\Code\TestCollection; use PHPUnit\Event\RuntimeException; use PHPUnit\Framework\DataProviderTestSuite; use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestSuite as FrameworkTestSuite; use PHPUnit\Runner\PhptTestCase; use ReflectionClass; use ReflectionException; use ReflectionMethod; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class TestSuiteBuilder { /** * @throws RuntimeException */ public static function from(FrameworkTestSuite $testSuite): TestSuite { $tests = []; self::process($testSuite, $tests); if ($testSuite instanceof DataProviderTestSuite) { [$className, $methodName] = explode('::', $testSuite->name()); try { $reflector = new ReflectionMethod($className, $methodName); return new TestSuiteForTestMethodWithDataProvider( $testSuite->name(), $testSuite->count(), TestCollection::fromArray($tests), $className, $methodName, $reflector->getFileName(), $reflector->getStartLine(), ); // @codeCoverageIgnoreStart } catch (ReflectionException $e) { throw new RuntimeException( $e->getMessage(), $e->getCode(), $e, ); } // @codeCoverageIgnoreEnd } if ($testSuite->isForTestClass()) { try { $reflector = new ReflectionClass($testSuite->name()); return new TestSuiteForTestClass( $testSuite->name(), $testSuite->count(), TestCollection::fromArray($tests), $reflector->getFileName(), $reflector->getStartLine(), ); // @codeCoverageIgnoreStart } catch (ReflectionException $e) { throw new RuntimeException( $e->getMessage(), $e->getCode(), $e, ); } // @codeCoverageIgnoreEnd } return new TestSuiteWithName( $testSuite->name(), $testSuite->count(), TestCollection::fromArray($tests), ); } /** * @psalm-param list $tests */ private static function process(FrameworkTestSuite $testSuite, array &$tests): void { foreach ($testSuite->getIterator() as $test) { if ($test instanceof FrameworkTestSuite) { self::process($test, $tests); continue; } if ($test instanceof TestCase || $test instanceof PhptTestCase) { $tests[] = $test->valueObjectForEvents(); } } } } Value/TestSuite/TestSuiteForTestClass.php000077500000002635000000000000014464 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use PHPUnit\Event\Code\TestCollection; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestSuiteForTestClass extends TestSuite { /** * @psalm-var class-string */ private readonly string $className; private readonly string $file; private readonly int $line; /** * @psalm-param class-string $name */ public function __construct(string $name, int $size, TestCollection $tests, string $file, int $line) { parent::__construct($name, $size, $tests); $this->className = $name; $this->file = $file; $this->line = $line; } /** * @psalm-return class-string */ public function className(): string { return $this->className; } public function file(): string { return $this->file; } public function line(): int { return $this->line; } /** * @psalm-assert-if-true TestSuiteForTestClass $this */ public function isForTestClass(): bool { return true; } } Value/TestSuite/TestSuiteWithName.php000077500000001152000000000000013615 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestSuiteWithName extends TestSuite { /** * @psalm-assert-if-true TestSuiteWithName $this */ public function isWithName(): bool { return true; } } Value/Telemetry/SystemMemoryMeter.php000077500000001375000000000000013731 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; use function memory_get_peak_usage; use function memory_get_usage; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class SystemMemoryMeter implements MemoryMeter { public function memoryUsage(): MemoryUsage { return MemoryUsage::fromBytes(memory_get_usage(true)); } public function peakMemoryUsage(): MemoryUsage { return MemoryUsage::fromBytes(memory_get_peak_usage(true)); } } Value/Telemetry/Php81GarbageCollectorStatusProvider.php000077500000001671000000000000017215 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; use function gc_status; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit * * @codeCoverageIgnore */ final class Php81GarbageCollectorStatusProvider implements GarbageCollectorStatusProvider { public function status(): GarbageCollectorStatus { $status = gc_status(); return new GarbageCollectorStatus( $status['runs'], $status['collected'], $status['threshold'], $status['roots'], null, null, null, null, null, null, null, null, ); } } Value/Telemetry/SystemStopWatchWithOffset.php000077500000001730000000000000015376 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; use function hrtime; use PHPUnit\Event\InvalidArgumentException; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit * * @codeCoverageIgnore */ final class SystemStopWatchWithOffset implements StopWatch { private ?HRTime $offset; public function __construct(HRTime $offset) { $this->offset = $offset; } /** * @throws InvalidArgumentException */ public function current(): HRTime { if ($this->offset !== null) { $offset = $this->offset; $this->offset = null; return $offset; } return HRTime::fromSecondsAndNanoseconds(...hrtime()); } } Value/Telemetry/MemoryMeter.php000077500000001005000000000000012512 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; /** * @internal This interface is not covered by the backward compatibility promise for PHPUnit */ interface MemoryMeter { public function memoryUsage(): MemoryUsage; public function peakMemoryUsage(): MemoryUsage; } Value/Telemetry/System.php000077500000002326000000000000011540 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class System { private readonly StopWatch $stopWatch; private readonly MemoryMeter $memoryMeter; private readonly GarbageCollectorStatusProvider $garbageCollectorStatusProvider; public function __construct(StopWatch $stopWatch, MemoryMeter $memoryMeter, GarbageCollectorStatusProvider $garbageCollectorStatusProvider) { $this->stopWatch = $stopWatch; $this->memoryMeter = $memoryMeter; $this->garbageCollectorStatusProvider = $garbageCollectorStatusProvider; } public function snapshot(): Snapshot { return new Snapshot( $this->stopWatch->current(), $this->memoryMeter->memoryUsage(), $this->memoryMeter->peakMemoryUsage(), $this->garbageCollectorStatusProvider->status(), ); } } Value/Telemetry/GarbageCollectorStatusProvider.php000077500000000751000000000000016372 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; /** * @internal This interface is not covered by the backward compatibility promise for PHPUnit */ interface GarbageCollectorStatusProvider { public function status(): GarbageCollectorStatus; } Value/Telemetry/Duration.php000077500000006727000000000000012052 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; use function floor; use function sprintf; use PHPUnit\Event\InvalidArgumentException; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Duration { private readonly int $seconds; private readonly int $nanoseconds; /** * @throws InvalidArgumentException */ public static function fromSecondsAndNanoseconds(int $seconds, int $nanoseconds): self { return new self( $seconds, $nanoseconds, ); } /** * @throws InvalidArgumentException */ private function __construct(int $seconds, int $nanoseconds) { $this->ensureNotNegative($seconds, 'seconds'); $this->ensureNotNegative($nanoseconds, 'nanoseconds'); $this->ensureNanoSecondsInRange($nanoseconds); $this->seconds = $seconds; $this->nanoseconds = $nanoseconds; } public function seconds(): int { return $this->seconds; } public function nanoseconds(): int { return $this->nanoseconds; } public function asFloat(): float { return $this->seconds() + ($this->nanoseconds() / 1000000000); } public function asString(): string { $seconds = $this->seconds(); $minutes = 0; $hours = 0; if ($seconds > 60 * 60) { $hours = floor($seconds / 60 / 60); $seconds -= ($hours * 60 * 60); } if ($seconds > 60) { $minutes = floor($seconds / 60); $seconds -= ($minutes * 60); } return sprintf( '%02d:%02d:%02d.%09d', $hours, $minutes, $seconds, $this->nanoseconds(), ); } public function equals(self $other): bool { return $this->seconds === $other->seconds && $this->nanoseconds === $other->nanoseconds; } public function isLessThan(self $other): bool { if ($this->seconds < $other->seconds) { return true; } if ($this->seconds > $other->seconds) { return false; } return $this->nanoseconds < $other->nanoseconds; } public function isGreaterThan(self $other): bool { if ($this->seconds > $other->seconds) { return true; } if ($this->seconds < $other->seconds) { return false; } return $this->nanoseconds > $other->nanoseconds; } /** * @throws InvalidArgumentException */ private function ensureNotNegative(int $value, string $type): void { if ($value < 0) { throw new InvalidArgumentException( sprintf( 'Value for %s must not be negative.', $type, ), ); } } /** * @throws InvalidArgumentException */ private function ensureNanoSecondsInRange(int $nanoseconds): void { if ($nanoseconds > 999999999) { throw new InvalidArgumentException( 'Value for nanoseconds must not be greater than 999999999.', ); } } } Value/Telemetry/MemoryUsage.php000077500000001546000000000000012514 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class MemoryUsage { private readonly int $bytes; public static function fromBytes(int $bytes): self { return new self($bytes); } private function __construct(int $bytes) { $this->bytes = $bytes; } public function bytes(): int { return $this->bytes; } public function diff(self $other): self { return self::fromBytes($this->bytes - $other->bytes); } } Value/Telemetry/GarbageCollectorStatus.php000077500000011250000000000000014653 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; use PHPUnit\Event\RuntimeException; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class GarbageCollectorStatus { private readonly int $runs; private readonly int $collected; private readonly int $threshold; private readonly int $roots; private readonly ?float $applicationTime; private readonly ?float $collectorTime; private readonly ?float $destructorTime; private readonly ?float $freeTime; private readonly ?bool $running; private readonly ?bool $protected; private readonly ?bool $full; private readonly ?int $bufferSize; public function __construct(int $runs, int $collected, int $threshold, int $roots, ?float $applicationTime, ?float $collectorTime, ?float $destructorTime, ?float $freeTime, ?bool $running, ?bool $protected, ?bool $full, ?int $bufferSize) { $this->runs = $runs; $this->collected = $collected; $this->threshold = $threshold; $this->roots = $roots; $this->applicationTime = $applicationTime; $this->collectorTime = $collectorTime; $this->destructorTime = $destructorTime; $this->freeTime = $freeTime; $this->running = $running; $this->protected = $protected; $this->full = $full; $this->bufferSize = $bufferSize; } public function runs(): int { return $this->runs; } public function collected(): int { return $this->collected; } public function threshold(): int { return $this->threshold; } public function roots(): int { return $this->roots; } /** * @psalm-assert-if-true !null $this->applicationTime * @psalm-assert-if-true !null $this->collectorTime * @psalm-assert-if-true !null $this->destructorTime * @psalm-assert-if-true !null $this->freeTime * @psalm-assert-if-true !null $this->running * @psalm-assert-if-true !null $this->protected * @psalm-assert-if-true !null $this->full * @psalm-assert-if-true !null $this->bufferSize */ public function hasExtendedInformation(): bool { return $this->running !== null; } /** * @throws RuntimeException on PHP < 8.3 */ public function applicationTime(): float { if ($this->applicationTime === null) { throw new RuntimeException('Information not available'); } return $this->applicationTime; } /** * @throws RuntimeException on PHP < 8.3 */ public function collectorTime(): float { if ($this->collectorTime === null) { throw new RuntimeException('Information not available'); } return $this->collectorTime; } /** * @throws RuntimeException on PHP < 8.3 */ public function destructorTime(): float { if ($this->destructorTime === null) { throw new RuntimeException('Information not available'); } return $this->destructorTime; } /** * @throws RuntimeException on PHP < 8.3 */ public function freeTime(): float { if ($this->freeTime === null) { throw new RuntimeException('Information not available'); } return $this->freeTime; } /** * @throws RuntimeException on PHP < 8.3 */ public function isRunning(): bool { if ($this->running === null) { throw new RuntimeException('Information not available'); } return $this->running; } /** * @throws RuntimeException on PHP < 8.3 */ public function isProtected(): bool { if ($this->protected === null) { throw new RuntimeException('Information not available'); } return $this->protected; } /** * @throws RuntimeException on PHP < 8.3 */ public function isFull(): bool { if ($this->full === null) { throw new RuntimeException('Information not available'); } return $this->full; } /** * @throws RuntimeException on PHP < 8.3 */ public function bufferSize(): int { if ($this->bufferSize === null) { throw new RuntimeException('Information not available'); } return $this->bufferSize; } } Value/Telemetry/HRTime.php000077500000005046000000000000011406 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; use function sprintf; use PHPUnit\Event\InvalidArgumentException; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class HRTime { private readonly int $seconds; private readonly int $nanoseconds; /** * @throws InvalidArgumentException */ public static function fromSecondsAndNanoseconds(int $seconds, int $nanoseconds): self { return new self( $seconds, $nanoseconds, ); } /** * @throws InvalidArgumentException */ private function __construct(int $seconds, int $nanoseconds) { $this->ensureNotNegative($seconds, 'seconds'); $this->ensureNotNegative($nanoseconds, 'nanoseconds'); $this->ensureNanoSecondsInRange($nanoseconds); $this->seconds = $seconds; $this->nanoseconds = $nanoseconds; } public function seconds(): int { return $this->seconds; } public function nanoseconds(): int { return $this->nanoseconds; } public function duration(self $start): Duration { $seconds = $this->seconds - $start->seconds(); $nanoseconds = $this->nanoseconds - $start->nanoseconds(); if ($nanoseconds < 0) { $seconds--; $nanoseconds += 1000000000; } if ($seconds < 0) { return Duration::fromSecondsAndNanoseconds(0, 0); } return Duration::fromSecondsAndNanoseconds( $seconds, $nanoseconds, ); } /** * @throws InvalidArgumentException */ private function ensureNotNegative(int $value, string $type): void { if ($value < 0) { throw new InvalidArgumentException( sprintf( 'Value for %s must not be negative.', $type, ), ); } } /** * @throws InvalidArgumentException */ private function ensureNanoSecondsInRange(int $nanoseconds): void { if ($nanoseconds > 999999999) { throw new InvalidArgumentException( 'Value for nanoseconds must not be greater than 999999999.', ); } } } Value/Telemetry/StopWatch.php000077500000000705000000000000012167 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; /** * @internal This interface is not covered by the backward compatibility promise for PHPUnit */ interface StopWatch { public function current(): HRTime; } Value/Telemetry/Snapshot.php000077500000002641000000000000012053 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Snapshot { private readonly HRTime $time; private readonly MemoryUsage $memoryUsage; private readonly MemoryUsage $peakMemoryUsage; private readonly GarbageCollectorStatus $garbageCollectorStatus; public function __construct(HRTime $time, MemoryUsage $memoryUsage, MemoryUsage $peakMemoryUsage, GarbageCollectorStatus $garbageCollectorStatus) { $this->time = $time; $this->memoryUsage = $memoryUsage; $this->peakMemoryUsage = $peakMemoryUsage; $this->garbageCollectorStatus = $garbageCollectorStatus; } public function time(): HRTime { return $this->time; } public function memoryUsage(): MemoryUsage { return $this->memoryUsage; } public function peakMemoryUsage(): MemoryUsage { return $this->peakMemoryUsage; } public function garbageCollectorStatus(): GarbageCollectorStatus { return $this->garbageCollectorStatus; } } Value/Telemetry/Php83GarbageCollectorStatusProvider.php000077500000002054000000000000017213 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; use function gc_status; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class Php83GarbageCollectorStatusProvider implements GarbageCollectorStatusProvider { public function status(): GarbageCollectorStatus { $status = gc_status(); return new GarbageCollectorStatus( $status['runs'], $status['collected'], $status['threshold'], $status['roots'], $status['application_time'], $status['collector_time'], $status['destructor_time'], $status['free_time'], $status['running'], $status['protected'], $status['full'], $status['buffer_size'], ); } } Value/Telemetry/SystemStopWatch.php000077500000001242000000000000013371 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; use function hrtime; use PHPUnit\Event\InvalidArgumentException; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class SystemStopWatch implements StopWatch { /** * @throws InvalidArgumentException */ public function current(): HRTime { return HRTime::fromSecondsAndNanoseconds(...hrtime()); } } Value/Telemetry/Info.php000077500000004501000000000000011144 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Telemetry; use function sprintf; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Info { private readonly Snapshot $current; private readonly Duration $durationSinceStart; private readonly MemoryUsage $memorySinceStart; private readonly Duration $durationSincePrevious; private readonly MemoryUsage $memorySincePrevious; public function __construct(Snapshot $current, Duration $durationSinceStart, MemoryUsage $memorySinceStart, Duration $durationSincePrevious, MemoryUsage $memorySincePrevious) { $this->current = $current; $this->durationSinceStart = $durationSinceStart; $this->memorySinceStart = $memorySinceStart; $this->durationSincePrevious = $durationSincePrevious; $this->memorySincePrevious = $memorySincePrevious; } public function time(): HRTime { return $this->current->time(); } public function memoryUsage(): MemoryUsage { return $this->current->memoryUsage(); } public function peakMemoryUsage(): MemoryUsage { return $this->current->peakMemoryUsage(); } public function durationSinceStart(): Duration { return $this->durationSinceStart; } public function memoryUsageSinceStart(): MemoryUsage { return $this->memorySinceStart; } public function durationSincePrevious(): Duration { return $this->durationSincePrevious; } public function memoryUsageSincePrevious(): MemoryUsage { return $this->memorySincePrevious; } public function garbageCollectorStatus(): GarbageCollectorStatus { return $this->current->garbageCollectorStatus(); } public function asString(): string { return sprintf( '[%s / %s] [%d bytes]', $this->durationSinceStart()->asString(), $this->durationSincePrevious()->asString(), $this->memoryUsage()->bytes(), ); } } Value/Throwable.php000077500000004527000000000000010236 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; use const PHP_EOL; use PHPUnit\Event\NoPreviousThrowableException; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Throwable { /** * @psalm-var class-string */ private readonly string $className; private readonly string $message; private readonly string $description; private readonly string $stackTrace; private readonly ?Throwable $previous; /** * @psalm-param class-string $className */ public function __construct(string $className, string $message, string $description, string $stackTrace, ?self $previous) { $this->className = $className; $this->message = $message; $this->description = $description; $this->stackTrace = $stackTrace; $this->previous = $previous; } /** * @throws NoPreviousThrowableException */ public function asString(): string { $buffer = $this->description(); if (!empty($this->stackTrace())) { $buffer .= PHP_EOL . $this->stackTrace(); } if ($this->hasPrevious()) { $buffer .= PHP_EOL . 'Caused by' . PHP_EOL . $this->previous()->asString(); } return $buffer; } /** * @psalm-return class-string */ public function className(): string { return $this->className; } public function message(): string { return $this->message; } public function description(): string { return $this->description; } public function stackTrace(): string { return $this->stackTrace; } /** * @psalm-assert-if-true !null $this->previous */ public function hasPrevious(): bool { return $this->previous !== null; } /** * @throws NoPreviousThrowableException */ public function previous(): self { if ($this->previous === null) { throw new NoPreviousThrowableException; } return $this->previous; } } Value/ComparisonFailure.php000077500000001753000000000000011727 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class ComparisonFailure { private readonly string $expected; private readonly string $actual; private readonly string $diff; public function __construct(string $expected, string $actual, string $diff) { $this->expected = $expected; $this->actual = $actual; $this->diff = $diff; } public function expected(): string { return $this->expected; } public function actual(): string { return $this->actual; } public function diff(): string { return $this->diff; } } Facade.php000077500000020113000000000000006363 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use function gc_status; use PHPUnit\Event\Telemetry\HRTime; use PHPUnit\Event\Telemetry\Php81GarbageCollectorStatusProvider; use PHPUnit\Event\Telemetry\Php83GarbageCollectorStatusProvider; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class Facade { private static ?self $instance = null; private Emitter $emitter; private ?TypeMap $typeMap = null; private ?DeferringDispatcher $deferringDispatcher = null; private bool $sealed = false; public static function instance(): self { if (self::$instance === null) { self::$instance = new self; } return self::$instance; } public static function emitter(): Emitter { return self::instance()->emitter; } public function __construct() { $this->emitter = $this->createDispatchingEmitter(); } /** * @throws EventFacadeIsSealedException * @throws UnknownSubscriberTypeException */ public function registerSubscribers(Subscriber ...$subscribers): void { foreach ($subscribers as $subscriber) { $this->registerSubscriber($subscriber); } } /** * @throws EventFacadeIsSealedException * @throws UnknownSubscriberTypeException */ public function registerSubscriber(Subscriber $subscriber): void { if ($this->sealed) { throw new EventFacadeIsSealedException; } $this->deferredDispatcher()->registerSubscriber($subscriber); } /** * @throws EventFacadeIsSealedException */ public function registerTracer(Tracer\Tracer $tracer): void { if ($this->sealed) { throw new EventFacadeIsSealedException; } $this->deferredDispatcher()->registerTracer($tracer); } /** * @codeCoverageIgnore * * @noinspection PhpUnused */ public function initForIsolation(HRTime $offset, bool $exportObjects): CollectingDispatcher { $dispatcher = new CollectingDispatcher; $this->emitter = new DispatchingEmitter( $dispatcher, new Telemetry\System( new Telemetry\SystemStopWatchWithOffset($offset), new Telemetry\SystemMemoryMeter, $this->garbageCollectorStatusProvider(), ), ); if ($exportObjects) { $this->emitter->exportObjects(); } $this->sealed = true; return $dispatcher; } public function forward(EventCollection $events): void { $dispatcher = $this->deferredDispatcher(); foreach ($events as $event) { $dispatcher->dispatch($event); } } public function seal(): void { $this->deferredDispatcher()->flush(); $this->sealed = true; $this->emitter->testRunnerEventFacadeSealed(); } private function createDispatchingEmitter(): DispatchingEmitter { return new DispatchingEmitter( $this->deferredDispatcher(), $this->createTelemetrySystem(), ); } private function createTelemetrySystem(): Telemetry\System { return new Telemetry\System( new Telemetry\SystemStopWatch, new Telemetry\SystemMemoryMeter, $this->garbageCollectorStatusProvider(), ); } private function deferredDispatcher(): DeferringDispatcher { if ($this->deferringDispatcher === null) { $this->deferringDispatcher = new DeferringDispatcher( new DirectDispatcher($this->typeMap()), ); } return $this->deferringDispatcher; } private function typeMap(): TypeMap { if ($this->typeMap === null) { $typeMap = new TypeMap; $this->registerDefaultTypes($typeMap); $this->typeMap = $typeMap; } return $this->typeMap; } private function registerDefaultTypes(TypeMap $typeMap): void { $defaultEvents = [ Application\Started::class, Application\Finished::class, Test\DataProviderMethodCalled::class, Test\DataProviderMethodFinished::class, Test\MarkedIncomplete::class, Test\AfterLastTestMethodCalled::class, Test\AfterLastTestMethodFinished::class, Test\AfterTestMethodCalled::class, Test\AfterTestMethodFinished::class, Test\AssertionSucceeded::class, Test\AssertionFailed::class, Test\BeforeFirstTestMethodCalled::class, Test\BeforeFirstTestMethodErrored::class, Test\BeforeFirstTestMethodFinished::class, Test\BeforeTestMethodCalled::class, Test\BeforeTestMethodFinished::class, Test\ComparatorRegistered::class, Test\ConsideredRisky::class, Test\DeprecationTriggered::class, Test\Errored::class, Test\ErrorTriggered::class, Test\Failed::class, Test\Finished::class, Test\NoticeTriggered::class, Test\Passed::class, Test\PhpDeprecationTriggered::class, Test\PhpNoticeTriggered::class, Test\PhpunitDeprecationTriggered::class, Test\PhpunitErrorTriggered::class, Test\PhpunitWarningTriggered::class, Test\PhpWarningTriggered::class, Test\PostConditionCalled::class, Test\PostConditionFinished::class, Test\PreConditionCalled::class, Test\PreConditionFinished::class, Test\PreparationStarted::class, Test\Prepared::class, Test\PreparationFailed::class, Test\PrintedUnexpectedOutput::class, Test\Skipped::class, Test\WarningTriggered::class, Test\MockObjectCreated::class, Test\MockObjectForAbstractClassCreated::class, Test\MockObjectForIntersectionOfInterfacesCreated::class, Test\MockObjectForTraitCreated::class, Test\MockObjectFromWsdlCreated::class, Test\PartialMockObjectCreated::class, Test\TestProxyCreated::class, Test\TestStubCreated::class, Test\TestStubForIntersectionOfInterfacesCreated::class, TestRunner\BootstrapFinished::class, TestRunner\Configured::class, TestRunner\EventFacadeSealed::class, TestRunner\ExecutionAborted::class, TestRunner\ExecutionFinished::class, TestRunner\ExecutionStarted::class, TestRunner\ExtensionLoadedFromPhar::class, TestRunner\ExtensionBootstrapped::class, TestRunner\Finished::class, TestRunner\Started::class, TestRunner\DeprecationTriggered::class, TestRunner\WarningTriggered::class, TestRunner\GarbageCollectionDisabled::class, TestRunner\GarbageCollectionTriggered::class, TestRunner\GarbageCollectionEnabled::class, TestSuite\Filtered::class, TestSuite\Finished::class, TestSuite\Loaded::class, TestSuite\Skipped::class, TestSuite\Sorted::class, TestSuite\Started::class, ]; foreach ($defaultEvents as $eventClass) { $typeMap->addMapping( $eventClass . 'Subscriber', $eventClass, ); } } private function garbageCollectorStatusProvider(): Telemetry\GarbageCollectorStatusProvider { if (!isset(gc_status()['running'])) { // @codeCoverageIgnoreStart return new Php81GarbageCollectorStatusProvider; // @codeCoverageIgnoreEnd } return new Php83GarbageCollectorStatusProvider; } } Exception/NoTestCaseObjectOnCallStackException.php000077500000001214000000000000016254 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code; use PHPUnit\Event\Exception; use RuntimeException; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class NoTestCaseObjectOnCallStackException extends RuntimeException implements Exception { public function __construct() { parent::__construct('Cannot find TestCase object on call stack'); } } Exception/EventFacadeIsSealedException.php000077500000000772000000000000014625 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class EventFacadeIsSealedException extends RuntimeException implements Exception { } Exception/InvalidEventException.php000077500000000763000000000000013436 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class InvalidEventException extends RuntimeException implements Exception { } Exception/NoComparisonFailureException.php000077500000001034000000000000014755 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Exception; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class NoComparisonFailureException extends RuntimeException implements Exception { } Exception/NoPreviousThrowableException.php000077500000000772000000000000015027 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class NoPreviousThrowableException extends RuntimeException implements Exception { } Exception/EventAlreadyAssignedException.php000077500000000773000000000000015110 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class EventAlreadyAssignedException extends RuntimeException implements Exception { } Exception/MapError.php000077500000000746000000000000010717 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class MapError extends RuntimeException implements Exception { } Exception/UnknownEventException.php000077500000000763000000000000013507 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class UnknownEventException extends RuntimeException implements Exception { } Exception/SubscriberTypeAlreadyRegisteredException.php000077500000001006000000000000017322 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class SubscriberTypeAlreadyRegisteredException extends RuntimeException implements Exception { } Exception/RuntimeException.php000077500000000730000000000000012463 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class RuntimeException extends \RuntimeException implements Exception { } Exception/InvalidSubscriberException.php000077500000000770000000000000014456 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class InvalidSubscriberException extends RuntimeException implements Exception { } Exception/UnknownSubscriberTypeException.php000077500000000774000000000000015375 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class UnknownSubscriberTypeException extends RuntimeException implements Exception { } Exception/UnknownEventTypeException.php000077500000000767000000000000014355 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class UnknownEventTypeException extends RuntimeException implements Exception { } Exception/InvalidArgumentException.php000077500000000750000000000000014133 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class InvalidArgumentException extends \InvalidArgumentException implements Exception { } Exception/UnknownSubscriberException.php000077500000000770000000000000014527 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class UnknownSubscriberException extends RuntimeException implements Exception { } Exception/Exception.php000077500000000512000000000000011115 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; interface Exception extends \PHPUnit\Exception { } Exception/NoDataSetFromDataProviderException.php000077500000001046000000000000016014 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestData; use PHPUnit\Event\Exception; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class NoDataSetFromDataProviderException extends RuntimeException implements Exception { } TypeMap.php000077500000012737000000000000006614 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use function array_key_exists; use function class_exists; use function class_implements; use function in_array; use function interface_exists; use function sprintf; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class TypeMap { /** * @psalm-var array */ private array $mapping = []; /** * @psalm-param class-string $subscriberInterface * @psalm-param class-string $eventClass * * @throws EventAlreadyAssignedException * @throws InvalidEventException * @throws InvalidSubscriberException * @throws SubscriberTypeAlreadyRegisteredException * @throws UnknownEventException * @throws UnknownSubscriberException */ public function addMapping(string $subscriberInterface, string $eventClass): void { $this->ensureSubscriberInterfaceExists($subscriberInterface); $this->ensureSubscriberInterfaceExtendsInterface($subscriberInterface); $this->ensureEventClassExists($eventClass); $this->ensureEventClassImplementsEventInterface($eventClass); $this->ensureSubscriberWasNotAlreadyRegistered($subscriberInterface); $this->ensureEventWasNotAlreadyAssigned($eventClass); $this->mapping[$subscriberInterface] = $eventClass; } public function isKnownSubscriberType(Subscriber $subscriber): bool { foreach (class_implements($subscriber) as $interface) { if (array_key_exists($interface, $this->mapping)) { return true; } } return false; } public function isKnownEventType(Event $event): bool { return in_array($event::class, $this->mapping, true); } /** * @psalm-return class-string * * @throws MapError */ public function map(Subscriber $subscriber): string { foreach (class_implements($subscriber) as $interface) { if (array_key_exists($interface, $this->mapping)) { return $this->mapping[$interface]; } } throw new MapError( sprintf( 'Subscriber "%s" does not implement a known interface', $subscriber::class, ), ); } /** * @psalm-param class-string $subscriberInterface * * @throws UnknownSubscriberException */ private function ensureSubscriberInterfaceExists(string $subscriberInterface): void { if (!interface_exists($subscriberInterface)) { throw new UnknownSubscriberException( sprintf( 'Subscriber "%s" does not exist or is not an interface', $subscriberInterface, ), ); } } /** * @psalm-param class-string $eventClass * * @throws UnknownEventException */ private function ensureEventClassExists(string $eventClass): void { if (!class_exists($eventClass)) { throw new UnknownEventException( sprintf( 'Event class "%s" does not exist', $eventClass, ), ); } } /** * @psalm-param class-string $subscriberInterface * * @throws InvalidSubscriberException */ private function ensureSubscriberInterfaceExtendsInterface(string $subscriberInterface): void { if (!in_array(Subscriber::class, class_implements($subscriberInterface), true)) { throw new InvalidSubscriberException( sprintf( 'Subscriber "%s" does not extend Subscriber interface', $subscriberInterface, ), ); } } /** * @psalm-param class-string $eventClass * * @throws InvalidEventException */ private function ensureEventClassImplementsEventInterface(string $eventClass): void { if (!in_array(Event::class, class_implements($eventClass), true)) { throw new InvalidEventException( sprintf( 'Event "%s" does not implement Event interface', $eventClass, ), ); } } /** * @psalm-param class-string $subscriberInterface * * @throws SubscriberTypeAlreadyRegisteredException */ private function ensureSubscriberWasNotAlreadyRegistered(string $subscriberInterface): void { if (array_key_exists($subscriberInterface, $this->mapping)) { throw new SubscriberTypeAlreadyRegisteredException( sprintf( 'Subscriber type "%s" already registered', $subscriberInterface, ), ); } } /** * @psalm-param class-string $eventClass * * @throws EventAlreadyAssignedException */ private function ensureEventWasNotAlreadyAssigned(string $eventClass): void { if (in_array($eventClass, $this->mapping, true)) { throw new EventAlreadyAssignedException( sprintf( 'Event "%s" already assigned', $eventClass, ), ); } } } Dispatcher/SubscribableDispatcher.php000077500000001172000000000000013721 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; /** * @internal This interface is not covered by the backward compatibility promise for PHPUnit */ interface SubscribableDispatcher extends Dispatcher { /** * @throws UnknownSubscriberTypeException */ public function registerSubscriber(Subscriber $subscriber): void; public function registerTracer(Tracer\Tracer $tracer): void; } Dispatcher/DeferringDispatcher.php000077500000002664000000000000013235 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class DeferringDispatcher implements SubscribableDispatcher { private readonly SubscribableDispatcher $dispatcher; private EventCollection $events; private bool $recording = true; public function __construct(SubscribableDispatcher $dispatcher) { $this->dispatcher = $dispatcher; $this->events = new EventCollection; } public function registerTracer(Tracer\Tracer $tracer): void { $this->dispatcher->registerTracer($tracer); } public function registerSubscriber(Subscriber $subscriber): void { $this->dispatcher->registerSubscriber($subscriber); } public function dispatch(Event $event): void { if ($this->recording) { $this->events->add($event); return; } $this->dispatcher->dispatch($event); } public function flush(): void { $this->recording = false; foreach ($this->events as $event) { $this->dispatcher->dispatch($event); } $this->events = new EventCollection; } } Dispatcher/CollectingDispatcher.php000077500000001470000000000000013405 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class CollectingDispatcher implements Dispatcher { private EventCollection $events; public function __construct() { $this->events = new EventCollection; } public function dispatch(Event $event): void { $this->events->add($event); } public function flush(): EventCollection { $events = $this->events; $this->events = new EventCollection; return $events; } } Dispatcher/DirectDispatcher.php000077500000007022000000000000012533 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use function array_key_exists; use function dirname; use function sprintf; use function str_starts_with; use Throwable; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class DirectDispatcher implements SubscribableDispatcher { private readonly TypeMap $typeMap; /** * @psalm-var array> */ private array $subscribers = []; /** * @psalm-var list */ private array $tracers = []; public function __construct(TypeMap $map) { $this->typeMap = $map; } public function registerTracer(Tracer\Tracer $tracer): void { $this->tracers[] = $tracer; } /** * @throws MapError * @throws UnknownSubscriberTypeException */ public function registerSubscriber(Subscriber $subscriber): void { if (!$this->typeMap->isKnownSubscriberType($subscriber)) { throw new UnknownSubscriberTypeException( sprintf( 'Subscriber "%s" does not implement any known interface - did you forget to register it?', $subscriber::class, ), ); } $eventClassName = $this->typeMap->map($subscriber); if (!array_key_exists($eventClassName, $this->subscribers)) { $this->subscribers[$eventClassName] = []; } $this->subscribers[$eventClassName][] = $subscriber; } /** * @throws Throwable * @throws UnknownEventTypeException */ public function dispatch(Event $event): void { $eventClassName = $event::class; if (!$this->typeMap->isKnownEventType($event)) { throw new UnknownEventTypeException( sprintf( 'Unknown event type "%s"', $eventClassName, ), ); } foreach ($this->tracers as $tracer) { try { $tracer->trace($event); // @codeCoverageIgnoreStart } catch (Throwable $t) { $this->handleThrowable($t); } // @codeCoverageIgnoreEnd } if (!array_key_exists($eventClassName, $this->subscribers)) { return; } foreach ($this->subscribers[$eventClassName] as $subscriber) { try { $subscriber->notify($event); } catch (Throwable $t) { $this->handleThrowable($t); } } } /** * @throws Throwable */ public function handleThrowable(Throwable $t): void { if ($this->isThrowableFromThirdPartySubscriber($t)) { Facade::emitter()->testRunnerTriggeredWarning( sprintf( 'Exception in third-party event subscriber: %s%s%s', $t->getMessage(), PHP_EOL, $t->getTraceAsString(), ), ); return; } // @codeCoverageIgnoreStart throw $t; // @codeCoverageIgnoreEnd } private function isThrowableFromThirdPartySubscriber(Throwable $t): bool { return !str_starts_with($t->getFile(), dirname(__DIR__, 2)); } } Dispatcher/Dispatcher.php000077500000001000000000000000011366 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; /** * @internal This interface is not covered by the backward compatibility promise for PHPUnit */ interface Dispatcher { /** * @throws UnknownEventTypeException */ public function dispatch(Event $event): void; } Tracer.php000077500000000755000000000000006452 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Tracer; use PHPUnit\Event\Event; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface Tracer { public function trace(Event $event): void; } Subscriber.php000077500000000641000000000000007327 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface Subscriber { } Emitter/Emitter.php000077500000024446000000000000010257 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use PHPUnit\Event\Code\ClassMethod; use PHPUnit\Event\Code\ComparisonFailure; use PHPUnit\Event\Code\Throwable; use PHPUnit\Event\TestSuite\TestSuite; use PHPUnit\Framework\Constraint; use PHPUnit\TextUI\Configuration\Configuration; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ interface Emitter { /** * @deprecated */ public function exportObjects(): void; /** * @deprecated */ public function exportsObjects(): bool; public function applicationStarted(): void; public function testRunnerStarted(): void; public function testRunnerConfigured(Configuration $configuration): void; public function testRunnerBootstrapFinished(string $filename): void; public function testRunnerLoadedExtensionFromPhar(string $filename, string $name, string $version): void; /** * @psalm-param class-string $className * @psalm-param array $parameters */ public function testRunnerBootstrappedExtension(string $className, array $parameters): void; public function dataProviderMethodCalled(ClassMethod $testMethod, ClassMethod $dataProviderMethod): void; public function dataProviderMethodFinished(ClassMethod $testMethod, ClassMethod ...$calledMethods): void; public function testSuiteLoaded(TestSuite $testSuite): void; public function testSuiteFiltered(TestSuite $testSuite): void; public function testSuiteSorted(int $executionOrder, int $executionOrderDefects, bool $resolveDependencies): void; public function testRunnerEventFacadeSealed(): void; public function testRunnerExecutionStarted(TestSuite $testSuite): void; public function testRunnerDisabledGarbageCollection(): void; public function testRunnerTriggeredGarbageCollection(): void; public function testSuiteSkipped(TestSuite $testSuite, string $message): void; public function testSuiteStarted(TestSuite $testSuite): void; public function testPreparationStarted(Code\Test $test): void; public function testPreparationFailed(Code\Test $test): void; /** * @psalm-param class-string $testClassName */ public function testBeforeFirstTestMethodCalled(string $testClassName, ClassMethod $calledMethod): void; /** * @psalm-param class-string $testClassName */ public function testBeforeFirstTestMethodErrored(string $testClassName, ClassMethod $calledMethod, Throwable $throwable): void; /** * @psalm-param class-string $testClassName */ public function testBeforeFirstTestMethodFinished(string $testClassName, ClassMethod ...$calledMethods): void; /** * @psalm-param class-string $testClassName */ public function testBeforeTestMethodCalled(string $testClassName, ClassMethod $calledMethod): void; /** * @psalm-param class-string $testClassName */ public function testBeforeTestMethodFinished(string $testClassName, ClassMethod ...$calledMethods): void; /** * @psalm-param class-string $testClassName */ public function testPreConditionCalled(string $testClassName, ClassMethod $calledMethod): void; /** * @psalm-param class-string $testClassName */ public function testPreConditionFinished(string $testClassName, ClassMethod ...$calledMethods): void; public function testPrepared(Code\Test $test): void; /** * @psalm-param class-string $className */ public function testRegisteredComparator(string $className): void; /** * @deprecated */ public function testAssertionSucceeded(mixed $value, Constraint\Constraint $constraint, string $message): void; /** * @deprecated */ public function testAssertionFailed(mixed $value, Constraint\Constraint $constraint, string $message): void; /** * @psalm-param class-string $className */ public function testCreatedMockObject(string $className): void; /** * @psalm-param list $interfaces */ public function testCreatedMockObjectForIntersectionOfInterfaces(array $interfaces): void; /** * @psalm-param trait-string $traitName */ public function testCreatedMockObjectForTrait(string $traitName): void; /** * @psalm-param class-string $className */ public function testCreatedMockObjectForAbstractClass(string $className): void; /** * @psalm-param class-string $originalClassName * @psalm-param class-string $mockClassName */ public function testCreatedMockObjectFromWsdl(string $wsdlFile, string $originalClassName, string $mockClassName, array $methods, bool $callOriginalConstructor, array $options): void; /** * @psalm-param class-string $className */ public function testCreatedPartialMockObject(string $className, string ...$methodNames): void; /** * @psalm-param class-string $className */ public function testCreatedTestProxy(string $className, array $constructorArguments): void; /** * @psalm-param class-string $className */ public function testCreatedStub(string $className): void; /** * @psalm-param list $interfaces */ public function testCreatedStubForIntersectionOfInterfaces(array $interfaces): void; public function testErrored(Code\Test $test, Throwable $throwable): void; public function testFailed(Code\Test $test, Throwable $throwable, ?ComparisonFailure $comparisonFailure): void; public function testPassed(Code\Test $test): void; /** * @psalm-param non-empty-string $message */ public function testConsideredRisky(Code\Test $test, string $message): void; public function testMarkedAsIncomplete(Code\Test $test, Throwable $throwable): void; /** * @psalm-param non-empty-string $message */ public function testSkipped(Code\Test $test, string $message): void; /** * @psalm-param non-empty-string $message */ public function testTriggeredPhpunitDeprecation(Code\Test $test, string $message): void; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function testTriggeredPhpDeprecation(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline, bool $ignoredByTest): void; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function testTriggeredDeprecation(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline, bool $ignoredByTest): void; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function testTriggeredError(Code\Test $test, string $message, string $file, int $line, bool $suppressed): void; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function testTriggeredNotice(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline): void; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function testTriggeredPhpNotice(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline): void; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function testTriggeredWarning(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline): void; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function testTriggeredPhpWarning(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline): void; /** * @psalm-param non-empty-string $message */ public function testTriggeredPhpunitError(Code\Test $test, string $message): void; /** * @psalm-param non-empty-string $message */ public function testTriggeredPhpunitWarning(Code\Test $test, string $message): void; /** * @psalm-param non-empty-string $output */ public function testPrintedUnexpectedOutput(string $output): void; public function testFinished(Code\Test $test, int $numberOfAssertionsPerformed): void; /** * @psalm-param class-string $testClassName */ public function testPostConditionCalled(string $testClassName, ClassMethod $calledMethod): void; /** * @psalm-param class-string $testClassName */ public function testPostConditionFinished(string $testClassName, ClassMethod ...$calledMethods): void; /** * @psalm-param class-string $testClassName */ public function testAfterTestMethodCalled(string $testClassName, ClassMethod $calledMethod): void; /** * @psalm-param class-string $testClassName */ public function testAfterTestMethodFinished(string $testClassName, ClassMethod ...$calledMethods): void; /** * @psalm-param class-string $testClassName */ public function testAfterLastTestMethodCalled(string $testClassName, ClassMethod $calledMethod): void; /** * @psalm-param class-string $testClassName */ public function testAfterLastTestMethodFinished(string $testClassName, ClassMethod ...$calledMethods): void; public function testSuiteFinished(TestSuite $testSuite): void; public function testRunnerTriggeredDeprecation(string $message): void; public function testRunnerTriggeredWarning(string $message): void; public function testRunnerEnabledGarbageCollection(): void; public function testRunnerExecutionAborted(): void; public function testRunnerExecutionFinished(): void; public function testRunnerFinished(): void; public function applicationFinished(int $shellExitCode): void; } Emitter/DispatchingEmitter.php000077500000102264000000000000012430 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use PHPUnit\Event\Code\ClassMethod; use PHPUnit\Event\Code\ComparisonFailure; use PHPUnit\Event\Code\Throwable; use PHPUnit\Event\Test\DataProviderMethodCalled; use PHPUnit\Event\Test\DataProviderMethodFinished; use PHPUnit\Event\TestSuite\Filtered as TestSuiteFiltered; use PHPUnit\Event\TestSuite\Finished as TestSuiteFinished; use PHPUnit\Event\TestSuite\Loaded as TestSuiteLoaded; use PHPUnit\Event\TestSuite\Skipped as TestSuiteSkipped; use PHPUnit\Event\TestSuite\Sorted as TestSuiteSorted; use PHPUnit\Event\TestSuite\Started as TestSuiteStarted; use PHPUnit\Event\TestSuite\TestSuite; use PHPUnit\Framework\Constraint; use PHPUnit\TextUI\Configuration\Configuration; use PHPUnit\Util\Exporter; /** * @internal This class is not covered by the backward compatibility promise for PHPUnit */ final class DispatchingEmitter implements Emitter { private readonly Dispatcher $dispatcher; private readonly Telemetry\System $system; private readonly Telemetry\Snapshot $startSnapshot; private Telemetry\Snapshot $previousSnapshot; private bool $exportObjects = false; public function __construct(Dispatcher $dispatcher, Telemetry\System $system) { $this->dispatcher = $dispatcher; $this->system = $system; $this->startSnapshot = $system->snapshot(); $this->previousSnapshot = $this->startSnapshot; } /** * @deprecated */ public function exportObjects(): void { $this->exportObjects = true; } /** * @deprecated */ public function exportsObjects(): bool { return $this->exportObjects; } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function applicationStarted(): void { $this->dispatcher->dispatch( new Application\Started( $this->telemetryInfo(), new Runtime\Runtime, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerStarted(): void { $this->dispatcher->dispatch( new TestRunner\Started( $this->telemetryInfo(), ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerConfigured(Configuration $configuration): void { $this->dispatcher->dispatch( new TestRunner\Configured( $this->telemetryInfo(), $configuration, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerBootstrapFinished(string $filename): void { $this->dispatcher->dispatch( new TestRunner\BootstrapFinished( $this->telemetryInfo(), $filename, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerLoadedExtensionFromPhar(string $filename, string $name, string $version): void { $this->dispatcher->dispatch( new TestRunner\ExtensionLoadedFromPhar( $this->telemetryInfo(), $filename, $name, $version, ), ); } /** * @psalm-param class-string $className * @psalm-param array $parameters * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerBootstrappedExtension(string $className, array $parameters): void { $this->dispatcher->dispatch( new TestRunner\ExtensionBootstrapped( $this->telemetryInfo(), $className, $parameters, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function dataProviderMethodCalled(ClassMethod $testMethod, ClassMethod $dataProviderMethod): void { $this->dispatcher->dispatch( new DataProviderMethodCalled( $this->telemetryInfo(), $testMethod, $dataProviderMethod, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function dataProviderMethodFinished(ClassMethod $testMethod, ClassMethod ...$calledMethods): void { $this->dispatcher->dispatch( new DataProviderMethodFinished( $this->telemetryInfo(), $testMethod, ...$calledMethods, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testSuiteLoaded(TestSuite $testSuite): void { $this->dispatcher->dispatch( new TestSuiteLoaded( $this->telemetryInfo(), $testSuite, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testSuiteFiltered(TestSuite $testSuite): void { $this->dispatcher->dispatch( new TestSuiteFiltered( $this->telemetryInfo(), $testSuite, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testSuiteSorted(int $executionOrder, int $executionOrderDefects, bool $resolveDependencies): void { $this->dispatcher->dispatch( new TestSuiteSorted( $this->telemetryInfo(), $executionOrder, $executionOrderDefects, $resolveDependencies, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerEventFacadeSealed(): void { $this->dispatcher->dispatch( new TestRunner\EventFacadeSealed( $this->telemetryInfo(), ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerExecutionStarted(TestSuite $testSuite): void { $this->dispatcher->dispatch( new TestRunner\ExecutionStarted( $this->telemetryInfo(), $testSuite, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerDisabledGarbageCollection(): void { $this->dispatcher->dispatch( new TestRunner\GarbageCollectionDisabled($this->telemetryInfo()), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerTriggeredGarbageCollection(): void { $this->dispatcher->dispatch( new TestRunner\GarbageCollectionTriggered($this->telemetryInfo()), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testSuiteSkipped(TestSuite $testSuite, string $message): void { $this->dispatcher->dispatch( new TestSuiteSkipped( $this->telemetryInfo(), $testSuite, $message, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testSuiteStarted(TestSuite $testSuite): void { $this->dispatcher->dispatch( new TestSuiteStarted( $this->telemetryInfo(), $testSuite, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testPreparationStarted(Code\Test $test): void { $this->dispatcher->dispatch( new Test\PreparationStarted( $this->telemetryInfo(), $test, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testPreparationFailed(Code\Test $test): void { $this->dispatcher->dispatch( new Test\PreparationFailed( $this->telemetryInfo(), $test, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testBeforeFirstTestMethodCalled(string $testClassName, ClassMethod $calledMethod): void { $this->dispatcher->dispatch( new Test\BeforeFirstTestMethodCalled( $this->telemetryInfo(), $testClassName, $calledMethod, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testBeforeFirstTestMethodErrored(string $testClassName, ClassMethod $calledMethod, Throwable $throwable): void { $this->dispatcher->dispatch( new Test\BeforeFirstTestMethodErrored( $this->telemetryInfo(), $testClassName, $calledMethod, $throwable, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testBeforeFirstTestMethodFinished(string $testClassName, ClassMethod ...$calledMethods): void { $this->dispatcher->dispatch( new Test\BeforeFirstTestMethodFinished( $this->telemetryInfo(), $testClassName, ...$calledMethods, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testBeforeTestMethodCalled(string $testClassName, ClassMethod $calledMethod): void { $this->dispatcher->dispatch( new Test\BeforeTestMethodCalled( $this->telemetryInfo(), $testClassName, $calledMethod, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testBeforeTestMethodFinished(string $testClassName, ClassMethod ...$calledMethods): void { $this->dispatcher->dispatch( new Test\BeforeTestMethodFinished( $this->telemetryInfo(), $testClassName, ...$calledMethods, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testPreConditionCalled(string $testClassName, ClassMethod $calledMethod): void { $this->dispatcher->dispatch( new Test\PreConditionCalled( $this->telemetryInfo(), $testClassName, $calledMethod, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testPreConditionFinished(string $testClassName, ClassMethod ...$calledMethods): void { $this->dispatcher->dispatch( new Test\PreConditionFinished( $this->telemetryInfo(), $testClassName, ...$calledMethods, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testPrepared(Code\Test $test): void { $this->dispatcher->dispatch( new Test\Prepared( $this->telemetryInfo(), $test, ), ); } /** * @psalm-param class-string $className * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRegisteredComparator(string $className): void { $this->dispatcher->dispatch( new Test\ComparatorRegistered( $this->telemetryInfo(), $className, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException * * @deprecated */ public function testAssertionSucceeded(mixed $value, Constraint\Constraint $constraint, string $message): void { $this->dispatcher->dispatch( new Test\AssertionSucceeded( $this->telemetryInfo(), Exporter::export($value, $this->exportObjects), $constraint->toString($this->exportObjects), $constraint->count(), $message, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException * * @deprecated */ public function testAssertionFailed(mixed $value, Constraint\Constraint $constraint, string $message): void { $this->dispatcher->dispatch( new Test\AssertionFailed( $this->telemetryInfo(), Exporter::export($value, $this->exportObjects), $constraint->toString($this->exportObjects), $constraint->count(), $message, ), ); } /** * @psalm-param class-string $className * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testCreatedMockObject(string $className): void { $this->dispatcher->dispatch( new Test\MockObjectCreated( $this->telemetryInfo(), $className, ), ); } /** * @psalm-param list $interfaces * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testCreatedMockObjectForIntersectionOfInterfaces(array $interfaces): void { $this->dispatcher->dispatch( new Test\MockObjectForIntersectionOfInterfacesCreated( $this->telemetryInfo(), $interfaces, ), ); } /** * @psalm-param trait-string $traitName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testCreatedMockObjectForTrait(string $traitName): void { $this->dispatcher->dispatch( new Test\MockObjectForTraitCreated( $this->telemetryInfo(), $traitName, ), ); } /** * @psalm-param class-string $className * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testCreatedMockObjectForAbstractClass(string $className): void { $this->dispatcher->dispatch( new Test\MockObjectForAbstractClassCreated( $this->telemetryInfo(), $className, ), ); } /** * @psalm-param class-string $originalClassName * @psalm-param class-string $mockClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testCreatedMockObjectFromWsdl(string $wsdlFile, string $originalClassName, string $mockClassName, array $methods, bool $callOriginalConstructor, array $options): void { $this->dispatcher->dispatch( new Test\MockObjectFromWsdlCreated( $this->telemetryInfo(), $wsdlFile, $originalClassName, $mockClassName, $methods, $callOriginalConstructor, $options, ), ); } /** * @psalm-param class-string $className * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testCreatedPartialMockObject(string $className, string ...$methodNames): void { $this->dispatcher->dispatch( new Test\PartialMockObjectCreated( $this->telemetryInfo(), $className, ...$methodNames, ), ); } /** * @psalm-param class-string $className * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testCreatedTestProxy(string $className, array $constructorArguments): void { $this->dispatcher->dispatch( new Test\TestProxyCreated( $this->telemetryInfo(), $className, Exporter::export($constructorArguments, $this->exportObjects), ), ); } /** * @psalm-param class-string $className * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testCreatedStub(string $className): void { $this->dispatcher->dispatch( new Test\TestStubCreated( $this->telemetryInfo(), $className, ), ); } /** * @psalm-param list $interfaces * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testCreatedStubForIntersectionOfInterfaces(array $interfaces): void { $this->dispatcher->dispatch( new Test\TestStubForIntersectionOfInterfacesCreated( $this->telemetryInfo(), $interfaces, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testErrored(Code\Test $test, Throwable $throwable): void { $this->dispatcher->dispatch( new Test\Errored( $this->telemetryInfo(), $test, $throwable, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testFailed(Code\Test $test, Throwable $throwable, ?ComparisonFailure $comparisonFailure): void { $this->dispatcher->dispatch( new Test\Failed( $this->telemetryInfo(), $test, $throwable, $comparisonFailure, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testPassed(Code\Test $test): void { $this->dispatcher->dispatch( new Test\Passed( $this->telemetryInfo(), $test, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testConsideredRisky(Code\Test $test, string $message): void { $this->dispatcher->dispatch( new Test\ConsideredRisky( $this->telemetryInfo(), $test, $message, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testMarkedAsIncomplete(Code\Test $test, Throwable $throwable): void { $this->dispatcher->dispatch( new Test\MarkedIncomplete( $this->telemetryInfo(), $test, $throwable, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testSkipped(Code\Test $test, string $message): void { $this->dispatcher->dispatch( new Test\Skipped( $this->telemetryInfo(), $test, $message, ), ); } /** * @psalm-param non-empty-string $message * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testTriggeredPhpunitDeprecation(Code\Test $test, string $message): void { $this->dispatcher->dispatch( new Test\PhpunitDeprecationTriggered( $this->telemetryInfo(), $test, $message, ), ); } /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testTriggeredPhpDeprecation(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline, bool $ignoredByTest): void { $this->dispatcher->dispatch( new Test\PhpDeprecationTriggered( $this->telemetryInfo(), $test, $message, $file, $line, $suppressed, $ignoredByBaseline, $ignoredByTest, ), ); } /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testTriggeredDeprecation(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline, bool $ignoredByTest): void { $this->dispatcher->dispatch( new Test\DeprecationTriggered( $this->telemetryInfo(), $test, $message, $file, $line, $suppressed, $ignoredByBaseline, $ignoredByTest, ), ); } /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testTriggeredError(Code\Test $test, string $message, string $file, int $line, bool $suppressed): void { $this->dispatcher->dispatch( new Test\ErrorTriggered( $this->telemetryInfo(), $test, $message, $file, $line, $suppressed, ), ); } /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testTriggeredNotice(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline): void { $this->dispatcher->dispatch( new Test\NoticeTriggered( $this->telemetryInfo(), $test, $message, $file, $line, $suppressed, $ignoredByBaseline, ), ); } /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testTriggeredPhpNotice(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline): void { $this->dispatcher->dispatch( new Test\PhpNoticeTriggered( $this->telemetryInfo(), $test, $message, $file, $line, $suppressed, $ignoredByBaseline, ), ); } /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testTriggeredWarning(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline): void { $this->dispatcher->dispatch( new Test\WarningTriggered( $this->telemetryInfo(), $test, $message, $file, $line, $suppressed, $ignoredByBaseline, ), ); } /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testTriggeredPhpWarning(Code\Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline): void { $this->dispatcher->dispatch( new Test\PhpWarningTriggered( $this->telemetryInfo(), $test, $message, $file, $line, $suppressed, $ignoredByBaseline, ), ); } /** * @psalm-param non-empty-string $message * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testTriggeredPhpunitError(Code\Test $test, string $message): void { $this->dispatcher->dispatch( new Test\PhpunitErrorTriggered( $this->telemetryInfo(), $test, $message, ), ); } /** * @psalm-param non-empty-string $message * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testTriggeredPhpunitWarning(Code\Test $test, string $message): void { $this->dispatcher->dispatch( new Test\PhpunitWarningTriggered( $this->telemetryInfo(), $test, $message, ), ); } /** * @psalm-param non-empty-string $output * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testPrintedUnexpectedOutput(string $output): void { $this->dispatcher->dispatch( new Test\PrintedUnexpectedOutput( $this->telemetryInfo(), $output, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testFinished(Code\Test $test, int $numberOfAssertionsPerformed): void { $this->dispatcher->dispatch( new Test\Finished( $this->telemetryInfo(), $test, $numberOfAssertionsPerformed, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testPostConditionCalled(string $testClassName, ClassMethod $calledMethod): void { $this->dispatcher->dispatch( new Test\PostConditionCalled( $this->telemetryInfo(), $testClassName, $calledMethod, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testPostConditionFinished(string $testClassName, ClassMethod ...$calledMethods): void { $this->dispatcher->dispatch( new Test\PostConditionFinished( $this->telemetryInfo(), $testClassName, ...$calledMethods, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testAfterTestMethodCalled(string $testClassName, ClassMethod $calledMethod): void { $this->dispatcher->dispatch( new Test\AfterTestMethodCalled( $this->telemetryInfo(), $testClassName, $calledMethod, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testAfterTestMethodFinished(string $testClassName, ClassMethod ...$calledMethods): void { $this->dispatcher->dispatch( new Test\AfterTestMethodFinished( $this->telemetryInfo(), $testClassName, ...$calledMethods, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testAfterLastTestMethodCalled(string $testClassName, ClassMethod $calledMethod): void { $this->dispatcher->dispatch( new Test\AfterLastTestMethodCalled( $this->telemetryInfo(), $testClassName, $calledMethod, ), ); } /** * @psalm-param class-string $testClassName * * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testAfterLastTestMethodFinished(string $testClassName, ClassMethod ...$calledMethods): void { $this->dispatcher->dispatch( new Test\AfterLastTestMethodFinished( $this->telemetryInfo(), $testClassName, ...$calledMethods, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testSuiteFinished(TestSuite $testSuite): void { $this->dispatcher->dispatch( new TestSuiteFinished( $this->telemetryInfo(), $testSuite, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerTriggeredDeprecation(string $message): void { $this->dispatcher->dispatch( new TestRunner\DeprecationTriggered( $this->telemetryInfo(), $message, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerTriggeredWarning(string $message): void { $this->dispatcher->dispatch( new TestRunner\WarningTriggered( $this->telemetryInfo(), $message, ), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerEnabledGarbageCollection(): void { $this->dispatcher->dispatch( new TestRunner\GarbageCollectionEnabled($this->telemetryInfo()), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerExecutionAborted(): void { $this->dispatcher->dispatch( new TestRunner\ExecutionAborted($this->telemetryInfo()), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerExecutionFinished(): void { $this->dispatcher->dispatch( new TestRunner\ExecutionFinished($this->telemetryInfo()), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function testRunnerFinished(): void { $this->dispatcher->dispatch( new TestRunner\Finished($this->telemetryInfo()), ); } /** * @throws InvalidArgumentException * @throws UnknownEventTypeException */ public function applicationFinished(int $shellExitCode): void { $this->dispatcher->dispatch( new Application\Finished( $this->telemetryInfo(), $shellExitCode, ), ); } /** * @throws InvalidArgumentException */ private function telemetryInfo(): Telemetry\Info { $current = $this->system->snapshot(); $info = new Telemetry\Info( $current, $current->time()->duration($this->startSnapshot->time()), $current->memoryUsage()->diff($this->startSnapshot->memoryUsage()), $current->time()->duration($this->previousSnapshot->time()), $current->memoryUsage()->diff($this->previousSnapshot->memoryUsage()), ); $this->previousSnapshot = $current; return $info; } } Events/EventCollectionIterator.php000077500000002243000000000000013277 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use function count; use Iterator; /** * @template-implements Iterator * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class EventCollectionIterator implements Iterator { /** * @psalm-var list */ private readonly array $events; private int $position = 0; public function __construct(EventCollection $events) { $this->events = $events->asArray(); } public function rewind(): void { $this->position = 0; } public function valid(): bool { return $this->position < count($this->events); } public function key(): int { return $this->position; } public function current(): Event { return $this->events[$this->position]; } public function next(): void { $this->position++; } } Events/TestRunner/GarbageCollectionEnabledSubscriber.php000077500000001071000000000000017442 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface GarbageCollectionEnabledSubscriber extends Subscriber { public function notify(GarbageCollectionEnabled $event): void; } Events/TestRunner/StartedSubscriber.php000077500000001027000000000000014232 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface StartedSubscriber extends Subscriber { public function notify(Started $event): void; } Events/TestRunner/GarbageCollectionEnabled.php000077500000001635000000000000015424 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class GarbageCollectionEnabled implements Event { private readonly Telemetry\Info $telemetryInfo; public function __construct(Telemetry\Info $telemetryInfo) { $this->telemetryInfo = $telemetryInfo; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function asString(): string { return 'Test Runner Enabled Garbage Collection'; } } Events/TestRunner/ExecutionAbortedSubscriber.php000077500000001051000000000000016065 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface ExecutionAbortedSubscriber extends Subscriber { public function notify(ExecutionAborted $event): void; } Events/TestRunner/GarbageCollectionDisabledSubscriber.php000077500000001073000000000000017621 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface GarbageCollectionDisabledSubscriber extends Subscriber { public function notify(GarbageCollectionDisabled $event): void; } Events/TestRunner/GarbageCollectionTriggeredSubscriber.php000077500000001075000000000000020030 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface GarbageCollectionTriggeredSubscriber extends Subscriber { public function notify(GarbageCollectionTriggered $event): void; } Events/TestRunner/ExecutionFinishedSubscriber.php000077500000001053000000000000016240 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface ExecutionFinishedSubscriber extends Subscriber { public function notify(ExecutionFinished $event): void; } Events/TestRunner/ExecutionAborted.php000077500000001614000000000000014046 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class ExecutionAborted implements Event { private readonly Telemetry\Info $telemetryInfo; public function __construct(Telemetry\Info $telemetryInfo) { $this->telemetryInfo = $telemetryInfo; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function asString(): string { return 'Test Runner Execution Aborted'; } } Events/TestRunner/ExecutionStartedSubscriber.php000077500000001051000000000000016113 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface ExecutionStartedSubscriber extends Subscriber { public function notify(ExecutionStarted $event): void; } Events/TestRunner/ExtensionBootstrapped.php000077500000003245000000000000015147 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class ExtensionBootstrapped implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $className; /** * @psalm-var array */ private readonly array $parameters; /** * @psalm-param class-string $className * @psalm-param array $parameters */ public function __construct(Telemetry\Info $telemetryInfo, string $className, array $parameters) { $this->telemetryInfo = $telemetryInfo; $this->className = $className; $this->parameters = $parameters; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function className(): string { return $this->className; } /** * @psalm-return array */ public function parameters(): array { return $this->parameters; } public function asString(): string { return sprintf( 'Extension Bootstrapped (%s)', $this->className, ); } } Events/TestRunner/ExtensionBootstrappedSubscriber.php000077500000001063000000000000017167 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface ExtensionBootstrappedSubscriber extends Subscriber { public function notify(ExtensionBootstrapped $event): void; } Events/TestRunner/GarbageCollectionDisabled.php000077500000001637000000000000015603 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class GarbageCollectionDisabled implements Event { private readonly Telemetry\Info $telemetryInfo; public function __construct(Telemetry\Info $telemetryInfo) { $this->telemetryInfo = $telemetryInfo; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function asString(): string { return 'Test Runner Disabled Garbage Collection'; } } Events/TestRunner/ExtensionLoadedFromPhar.php000077500000003017000000000000015325 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class ExtensionLoadedFromPhar implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly string $filename; private readonly string $name; private readonly string $version; public function __construct(Telemetry\Info $telemetryInfo, string $filename, string $name, string $version) { $this->telemetryInfo = $telemetryInfo; $this->filename = $filename; $this->name = $name; $this->version = $version; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function filename(): string { return $this->filename; } public function name(): string { return $this->name; } public function version(): string { return $this->version; } public function asString(): string { return sprintf( 'Extension Loaded from PHAR (%s %s)', $this->name, $this->version, ); } } Events/TestRunner/EventFacadeSealed.php000077500000001603000000000000014063 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class EventFacadeSealed implements Event { private readonly Telemetry\Info $telemetryInfo; public function __construct(Telemetry\Info $telemetryInfo) { $this->telemetryInfo = $telemetryInfo; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function asString(): string { return 'Event Facade Sealed'; } } Events/TestRunner/DeprecationTriggered.php000077500000002235000000000000014674 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class DeprecationTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly string $message; public function __construct(Telemetry\Info $telemetryInfo, string $message) { $this->telemetryInfo = $telemetryInfo; $this->message = $message; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function message(): string { return $this->message; } public function asString(): string { return sprintf( 'Test Runner Triggered Deprecation (%s)', $this->message, ); } } Events/TestRunner/Configured.php000077500000002175000000000000012672 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; use PHPUnit\TextUI\Configuration\Configuration; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Configured implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Configuration $configuration; public function __construct(Telemetry\Info $telemetryInfo, Configuration $configuration) { $this->telemetryInfo = $telemetryInfo; $this->configuration = $configuration; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function configuration(): Configuration { return $this->configuration; } public function asString(): string { return 'Test Runner Configured'; } } Events/TestRunner/BootstrapFinishedSubscriber.php000077500000001053000000000000016252 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface BootstrapFinishedSubscriber extends Subscriber { public function notify(BootstrapFinished $event): void; } Events/TestRunner/GarbageCollectionTriggered.php000077500000001641000000000000016003 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class GarbageCollectionTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; public function __construct(Telemetry\Info $telemetryInfo) { $this->telemetryInfo = $telemetryInfo; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function asString(): string { return 'Test Runner Triggered Garbage Collection'; } } Events/TestRunner/WarningTriggeredSubscriber.php000077500000001051000000000000016063 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface WarningTriggeredSubscriber extends Subscriber { public function notify(WarningTriggered $event): void; } Events/TestRunner/BootstrapFinished.php000077500000002221000000000000014224 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class BootstrapFinished implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly string $filename; public function __construct(Telemetry\Info $telemetryInfo, string $filename) { $this->telemetryInfo = $telemetryInfo; $this->filename = $filename; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function filename(): string { return $this->filename; } public function asString(): string { return sprintf( 'Bootstrap Finished (%s)', $this->filename, ); } } Events/TestRunner/WarningTriggered.php000077500000002225000000000000014043 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class WarningTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly string $message; public function __construct(Telemetry\Info $telemetryInfo, string $message) { $this->telemetryInfo = $telemetryInfo; $this->message = $message; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function message(): string { return $this->message; } public function asString(): string { return sprintf( 'Test Runner Triggered Warning (%s)', $this->message, ); } } Events/TestRunner/ExecutionStarted.php000077500000002431000000000000014072 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; use PHPUnit\Event\TestSuite\TestSuite; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class ExecutionStarted implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly TestSuite $testSuite; public function __construct(Telemetry\Info $telemetryInfo, TestSuite $testSuite) { $this->telemetryInfo = $telemetryInfo; $this->testSuite = $testSuite; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function testSuite(): TestSuite { return $this->testSuite; } public function asString(): string { return sprintf( 'Test Runner Execution Started (%d test%s)', $this->testSuite->count(), $this->testSuite->count() !== 1 ? 's' : '', ); } } Events/TestRunner/ExecutionFinished.php000077500000001616000000000000014221 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class ExecutionFinished implements Event { private readonly Telemetry\Info $telemetryInfo; public function __construct(Telemetry\Info $telemetryInfo) { $this->telemetryInfo = $telemetryInfo; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function asString(): string { return 'Test Runner Execution Finished'; } } Events/TestRunner/Started.php000077500000001571000000000000012212 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Started implements Event { private readonly Telemetry\Info $telemetryInfo; public function __construct(Telemetry\Info $telemetryInfo) { $this->telemetryInfo = $telemetryInfo; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function asString(): string { return 'Test Runner Started'; } } Events/TestRunner/ConfiguredSubscriber.php000077500000001035000000000000014710 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface ConfiguredSubscriber extends Subscriber { public function notify(Configured $event): void; } Events/TestRunner/EventFacadeSealedSubscriber.php000077500000001053000000000000016106 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface EventFacadeSealedSubscriber extends Subscriber { public function notify(EventFacadeSealed $event): void; } Events/TestRunner/Finished.php000077500000001573000000000000012337 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Finished implements Event { private readonly Telemetry\Info $telemetryInfo; public function __construct(Telemetry\Info $telemetryInfo) { $this->telemetryInfo = $telemetryInfo; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function asString(): string { return 'Test Runner Finished'; } } Events/TestRunner/FinishedSubscriber.php000077500000001031000000000000014350 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface FinishedSubscriber extends Subscriber { public function notify(Finished $event): void; } Events/TestRunner/ExtensionLoadedFromPharSubscriber.php000077500000001067000000000000017354 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface ExtensionLoadedFromPharSubscriber extends Subscriber { public function notify(ExtensionLoadedFromPhar $event): void; } Events/TestRunner/DeprecationTriggeredSubscriber.php000077500000001061000000000000016714 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface DeprecationTriggeredSubscriber extends Subscriber { public function notify(DeprecationTriggered $event): void; } Events/Test/ComparatorRegisteredSubscriber.php000077500000001053000000000000015556 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface ComparatorRegisteredSubscriber extends Subscriber { public function notify(ComparatorRegistered $event): void; } Events/Test/Issue/PhpunitErrorTriggered.php000077500000003266000000000000015003 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use function trim; use PHPUnit\Event\Code\Test; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PhpunitErrorTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Test $test; /** * @psalm-var non-empty-string */ private readonly string $message; /** * @psalm-param non-empty-string $message */ public function __construct(Telemetry\Info $telemetryInfo, Test $test, string $message) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->message = $message; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Test { return $this->test; } /** * @psalm-return non-empty-string */ public function message(): string { return $this->message; } public function asString(): string { $message = trim($this->message); if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'Test Triggered PHPUnit Error (%s)%s', $this->test->id(), $message, ); } } Events/Test/Issue/PhpunitDeprecationTriggeredSubscriber.php000077500000001071000000000000020163 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PhpunitDeprecationTriggeredSubscriber extends Subscriber { public function notify(PhpunitDeprecationTriggered $event): void; } Events/Test/Issue/PhpWarningTriggered.php000077500000005604000000000000014415 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code\Test; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PhpWarningTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Test $test; /** * @psalm-var non-empty-string */ private readonly string $message; /** * @psalm-var non-empty-string */ private readonly string $file; /** * @psalm-var positive-int */ private readonly int $line; private readonly bool $suppressed; private readonly bool $ignoredByBaseline; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function __construct(Telemetry\Info $telemetryInfo, Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->message = $message; $this->file = $file; $this->line = $line; $this->suppressed = $suppressed; $this->ignoredByBaseline = $ignoredByBaseline; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Test { return $this->test; } /** * @psalm-return non-empty-string */ public function message(): string { return $this->message; } /** * @psalm-return non-empty-string */ public function file(): string { return $this->file; } /** * @psalm-return positive-int */ public function line(): int { return $this->line; } public function wasSuppressed(): bool { return $this->suppressed; } public function ignoredByBaseline(): bool { return $this->ignoredByBaseline; } public function asString(): string { $message = $this->message; if (!empty($message)) { $message = PHP_EOL . $message; } $status = ''; if ($this->ignoredByBaseline) { $status = 'Baseline-Ignored '; } elseif ($this->suppressed) { $status = 'Suppressed '; } return sprintf( 'Test Triggered %sPHP Warning (%s)%s', $status, $this->test->id(), $message, ); } } Events/Test/Issue/PhpNoticeTriggered.php000077500000005602000000000000014227 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code\Test; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PhpNoticeTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Test $test; /** * @psalm-var non-empty-string */ private readonly string $message; /** * @psalm-var non-empty-string */ private readonly string $file; /** * @psalm-var positive-int */ private readonly int $line; private readonly bool $suppressed; private readonly bool $ignoredByBaseline; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function __construct(Telemetry\Info $telemetryInfo, Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->message = $message; $this->file = $file; $this->line = $line; $this->suppressed = $suppressed; $this->ignoredByBaseline = $ignoredByBaseline; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Test { return $this->test; } /** * @psalm-return non-empty-string */ public function message(): string { return $this->message; } /** * @psalm-return non-empty-string */ public function file(): string { return $this->file; } /** * @psalm-return positive-int */ public function line(): int { return $this->line; } public function wasSuppressed(): bool { return $this->suppressed; } public function ignoredByBaseline(): bool { return $this->ignoredByBaseline; } public function asString(): string { $message = $this->message; if (!empty($message)) { $message = PHP_EOL . $message; } $status = ''; if ($this->ignoredByBaseline) { $status = 'Baseline-Ignored '; } elseif ($this->suppressed) { $status = 'Suppressed '; } return sprintf( 'Test Triggered %sPHP Notice (%s)%s', $status, $this->test->id(), $message, ); } } Events/Test/Issue/PhpDeprecationTriggeredSubscriber.php000077500000001061000000000000017262 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PhpDeprecationTriggeredSubscriber extends Subscriber { public function notify(PhpDeprecationTriggered $event): void; } Events/Test/Issue/ErrorTriggered.php000077500000004742000000000000013433 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code\Test; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class ErrorTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Test $test; /** * @psalm-var non-empty-string */ private readonly string $message; /** * @psalm-var non-empty-string */ private readonly string $file; /** * @psalm-var positive-int */ private readonly int $line; private readonly bool $suppressed; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function __construct(Telemetry\Info $telemetryInfo, Test $test, string $message, string $file, int $line, bool $suppressed) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->message = $message; $this->file = $file; $this->line = $line; $this->suppressed = $suppressed; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Test { return $this->test; } /** * @psalm-return non-empty-string */ public function message(): string { return $this->message; } /** * @psalm-return non-empty-string */ public function file(): string { return $this->file; } /** * @psalm-return positive-int */ public function line(): int { return $this->line; } public function wasSuppressed(): bool { return $this->suppressed; } public function asString(): string { $message = $this->message; if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'Test Triggered %sError (%s)%s', $this->wasSuppressed() ? 'Suppressed ' : '', $this->test->id(), $message, ); } } Events/Test/Issue/NoticeTriggered.php000077500000005573000000000000013566 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code\Test; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class NoticeTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Test $test; /** * @psalm-var non-empty-string */ private readonly string $message; /** * @psalm-var non-empty-string */ private readonly string $file; /** * @psalm-var positive-int */ private readonly int $line; private readonly bool $suppressed; private readonly bool $ignoredByBaseline; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function __construct(Telemetry\Info $telemetryInfo, Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->message = $message; $this->file = $file; $this->line = $line; $this->suppressed = $suppressed; $this->ignoredByBaseline = $ignoredByBaseline; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Test { return $this->test; } /** * @psalm-return non-empty-string */ public function message(): string { return $this->message; } /** * @psalm-return non-empty-string */ public function file(): string { return $this->file; } /** * @psalm-return positive-int */ public function line(): int { return $this->line; } public function wasSuppressed(): bool { return $this->suppressed; } public function ignoredByBaseline(): bool { return $this->ignoredByBaseline; } public function asString(): string { $message = $this->message; if (!empty($message)) { $message = PHP_EOL . $message; } $status = ''; if ($this->ignoredByBaseline) { $status = 'Baseline-Ignored '; } elseif ($this->suppressed) { $status = 'Suppressed '; } return sprintf( 'Test Triggered %sNotice (%s)%s', $status, $this->test->id(), $message, ); } } Events/Test/Issue/ConsideredRiskySubscriber.php000077500000001041000000000000015617 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface ConsideredRiskySubscriber extends Subscriber { public function notify(ConsideredRisky $event): void; } Events/Test/Issue/PhpWarningTriggeredSubscriber.php000077500000001051000000000000016431 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PhpWarningTriggeredSubscriber extends Subscriber { public function notify(PhpWarningTriggered $event): void; } Events/Test/Issue/PhpunitWarningTriggered.php000077500000003241000000000000015310 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code\Test; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PhpunitWarningTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Test $test; /** * @psalm-var non-empty-string */ private readonly string $message; /** * @psalm-param non-empty-string $message */ public function __construct(Telemetry\Info $telemetryInfo, Test $test, string $message) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->message = $message; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Test { return $this->test; } /** * @psalm-return non-empty-string */ public function message(): string { return $this->message; } public function asString(): string { $message = $this->message; if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'Test Triggered PHPUnit Warning (%s)%s', $this->test->id(), $message, ); } } Events/Test/Issue/NoticeTriggeredSubscriber.php000077500000001041000000000000015574 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface NoticeTriggeredSubscriber extends Subscriber { public function notify(NoticeTriggered $event): void; } Events/Test/Issue/PhpunitDeprecationTriggered.php000077500000003251000000000000016141 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code\Test; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PhpunitDeprecationTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Test $test; /** * @psalm-var non-empty-string */ private readonly string $message; /** * @psalm-param non-empty-string $message */ public function __construct(Telemetry\Info $telemetryInfo, Test $test, string $message) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->message = $message; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Test { return $this->test; } /** * @psalm-return non-empty-string */ public function message(): string { return $this->message; } public function asString(): string { $message = $this->message; if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'Test Triggered PHPUnit Deprecation (%s)%s', $this->test->id(), $message, ); } } Events/Test/Issue/ConsideredRisky.php000077500000003075000000000000013604 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class ConsideredRisky implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Code\Test $test; /** * @psalm-var non-empty-string */ private readonly string $message; /** * @psalm-param non-empty-string $message */ public function __construct(Telemetry\Info $telemetryInfo, Code\Test $test, string $message) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->message = $message; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Code\Test { return $this->test; } /** * @psalm-return non-empty-string */ public function message(): string { return $this->message; } public function asString(): string { return sprintf( 'Test Considered Risky (%s)%s%s', $this->test->id(), PHP_EOL, $this->message, ); } } Events/Test/Issue/DeprecationTriggered.php000077500000006244000000000000014576 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code\Test; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class DeprecationTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Test $test; /** * @psalm-var non-empty-string */ private readonly string $message; /** * @psalm-var non-empty-string */ private readonly string $file; /** * @psalm-var positive-int */ private readonly int $line; private readonly bool $suppressed; private readonly bool $ignoredByBaseline; private readonly bool $ignoredByTest; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function __construct(Telemetry\Info $telemetryInfo, Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline, bool $ignoredByTest) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->message = $message; $this->file = $file; $this->line = $line; $this->suppressed = $suppressed; $this->ignoredByBaseline = $ignoredByBaseline; $this->ignoredByTest = $ignoredByTest; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Test { return $this->test; } /** * @psalm-return non-empty-string */ public function message(): string { return $this->message; } /** * @psalm-return non-empty-string */ public function file(): string { return $this->file; } /** * @psalm-return positive-int */ public function line(): int { return $this->line; } public function wasSuppressed(): bool { return $this->suppressed; } public function ignoredByBaseline(): bool { return $this->ignoredByBaseline; } public function ignoredByTest(): bool { return $this->ignoredByTest; } public function asString(): string { $message = $this->message; if (!empty($message)) { $message = PHP_EOL . $message; } $status = ''; if ($this->ignoredByTest) { $status = 'Test-Ignored '; } elseif ($this->ignoredByBaseline) { $status = 'Baseline-Ignored '; } elseif ($this->suppressed) { $status = 'Suppressed '; } return sprintf( 'Test Triggered %sDeprecation (%s)%s', $status, $this->test->id(), $message, ); } } Events/Test/Issue/PhpunitWarningTriggeredSubscriber.php000077500000001061000000000000017332 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PhpunitWarningTriggeredSubscriber extends Subscriber { public function notify(PhpunitWarningTriggered $event): void; } Events/Test/Issue/WarningTriggeredSubscriber.php000077500000001043000000000000015762 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface WarningTriggeredSubscriber extends Subscriber { public function notify(WarningTriggered $event): void; } Events/Test/Issue/WarningTriggered.php000077500000005575000000000000013754 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code\Test; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class WarningTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Test $test; /** * @psalm-var non-empty-string */ private readonly string $message; /** * @psalm-var non-empty-string */ private readonly string $file; /** * @psalm-var positive-int */ private readonly int $line; private readonly bool $suppressed; private readonly bool $ignoredByBaseline; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function __construct(Telemetry\Info $telemetryInfo, Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->message = $message; $this->file = $file; $this->line = $line; $this->suppressed = $suppressed; $this->ignoredByBaseline = $ignoredByBaseline; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Test { return $this->test; } /** * @psalm-return non-empty-string */ public function message(): string { return $this->message; } /** * @psalm-return non-empty-string */ public function file(): string { return $this->file; } /** * @psalm-return positive-int */ public function line(): int { return $this->line; } public function wasSuppressed(): bool { return $this->suppressed; } public function ignoredByBaseline(): bool { return $this->ignoredByBaseline; } public function asString(): string { $message = $this->message; if (!empty($message)) { $message = PHP_EOL . $message; } $status = ''; if ($this->ignoredByBaseline) { $status = 'Baseline-Ignored '; } elseif ($this->suppressed) { $status = 'Suppressed '; } return sprintf( 'Test Triggered %sWarning (%s)%s', $status, $this->test->id(), $message, ); } } Events/Test/Issue/ErrorTriggeredSubscriber.php000077500000001037000000000000015451 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface ErrorTriggeredSubscriber extends Subscriber { public function notify(ErrorTriggered $event): void; } Events/Test/Issue/PhpunitErrorTriggeredSubscriber.php000077500000001055000000000000017021 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PhpunitErrorTriggeredSubscriber extends Subscriber { public function notify(PhpunitErrorTriggered $event): void; } Events/Test/Issue/PhpDeprecationTriggered.php000077500000006253000000000000015246 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code\Test; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PhpDeprecationTriggered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Test $test; /** * @psalm-var non-empty-string */ private readonly string $message; /** * @psalm-var non-empty-string */ private readonly string $file; /** * @psalm-var positive-int */ private readonly int $line; private readonly bool $suppressed; private readonly bool $ignoredByBaseline; private readonly bool $ignoredByTest; /** * @psalm-param non-empty-string $message * @psalm-param non-empty-string $file * @psalm-param positive-int $line */ public function __construct(Telemetry\Info $telemetryInfo, Test $test, string $message, string $file, int $line, bool $suppressed, bool $ignoredByBaseline, bool $ignoredByTest) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->message = $message; $this->file = $file; $this->line = $line; $this->suppressed = $suppressed; $this->ignoredByBaseline = $ignoredByBaseline; $this->ignoredByTest = $ignoredByTest; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Test { return $this->test; } /** * @psalm-return non-empty-string */ public function message(): string { return $this->message; } /** * @psalm-return non-empty-string */ public function file(): string { return $this->file; } /** * @psalm-return positive-int */ public function line(): int { return $this->line; } public function wasSuppressed(): bool { return $this->suppressed; } public function ignoredByBaseline(): bool { return $this->ignoredByBaseline; } public function ignoredByTest(): bool { return $this->ignoredByTest; } public function asString(): string { $message = $this->message; if (!empty($message)) { $message = PHP_EOL . $message; } $status = ''; if ($this->ignoredByTest) { $status = 'Test-Ignored '; } elseif ($this->ignoredByBaseline) { $status = 'Baseline-Ignored '; } elseif ($this->suppressed) { $status = 'Suppressed '; } return sprintf( 'Test Triggered %sPHP Deprecation (%s)%s', $status, $this->test->id(), $message, ); } } Events/Test/Issue/PhpNoticeTriggeredSubscriber.php000077500000001047000000000000016252 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PhpNoticeTriggeredSubscriber extends Subscriber { public function notify(PhpNoticeTriggered $event): void; } Events/Test/Issue/DeprecationTriggeredSubscriber.php000077500000001053000000000000016613 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface DeprecationTriggeredSubscriber extends Subscriber { public function notify(DeprecationTriggered $event): void; } Events/Test/PrintedUnexpectedOutput.php000077500000002514000000000000014263 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PrintedUnexpectedOutput implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var non-empty-string */ private readonly string $output; /** * @psalm-param non-empty-string $output */ public function __construct(Telemetry\Info $telemetryInfo, string $output) { $this->telemetryInfo = $telemetryInfo; $this->output = $output; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return non-empty-string */ public function output(): string { return $this->output; } public function asString(): string { return sprintf( 'Test Printed Unexpected Output%s%s', PHP_EOL, $this->output, ); } } Events/Test/HookMethod/AfterLastTestMethodFinished.php000077500000003647000000000000017021 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class AfterLastTestMethodFinished implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; /** * @psalm-var list */ private readonly array $calledMethods; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod ...$calledMethods) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethods = $calledMethods; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } /** * @psalm-return list */ public function calledMethods(): array { return $this->calledMethods; } public function asString(): string { $buffer = 'After Last Test Method Finished:'; foreach ($this->calledMethods as $calledMethod) { $buffer .= sprintf( PHP_EOL . '- %s::%s', $calledMethod->className(), $calledMethod->methodName(), ); } return $buffer; } } Events/Test/HookMethod/BeforeFirstTestMethodErroredSubscriber.php000077500000001073000000000000021232 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface BeforeFirstTestMethodErroredSubscriber extends Subscriber { public function notify(BeforeFirstTestMethodErrored $event): void; } Events/Test/HookMethod/BeforeTestMethodFinished.php000077500000003640000000000000016327 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class BeforeTestMethodFinished implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; /** * @psalm-var list */ private readonly array $calledMethods; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod ...$calledMethods) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethods = $calledMethods; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } /** * @psalm-return list */ public function calledMethods(): array { return $this->calledMethods; } public function asString(): string { $buffer = 'Before Test Method Finished:'; foreach ($this->calledMethods as $calledMethod) { $buffer .= sprintf( PHP_EOL . '- %s::%s', $calledMethod->className(), $calledMethod->methodName(), ); } return $buffer; } } Events/Test/HookMethod/AfterTestMethodFinished.php000077500000003636000000000000016173 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class AfterTestMethodFinished implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; /** * @psalm-var list */ private readonly array $calledMethods; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod ...$calledMethods) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethods = $calledMethods; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } /** * @psalm-return list */ public function calledMethods(): array { return $this->calledMethods; } public function asString(): string { $buffer = 'After Test Method Finished:'; foreach ($this->calledMethods as $calledMethod) { $buffer .= sprintf( PHP_EOL . '- %s::%s', $calledMethod->className(), $calledMethod->methodName(), ); } return $buffer; } } Events/Test/HookMethod/PostConditionCalled.php000077500000003227000000000000015354 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PostConditionCalled implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; private readonly Code\ClassMethod $calledMethod; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod $calledMethod) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethod = $calledMethod; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } public function calledMethod(): Code\ClassMethod { return $this->calledMethod; } public function asString(): string { return sprintf( 'Post Condition Method Called (%s::%s)', $this->calledMethod->className(), $this->calledMethod->methodName(), ); } } Events/Test/HookMethod/PostConditionCalledSubscriber.php000077500000001051000000000000017371 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PostConditionCalledSubscriber extends Subscriber { public function notify(PostConditionCalled $event): void; } Events/Test/HookMethod/AfterTestMethodCalledSubscriber.php000077500000001055000000000000017643 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface AfterTestMethodCalledSubscriber extends Subscriber { public function notify(AfterTestMethodCalled $event): void; } Events/Test/HookMethod/BeforeTestMethodCalledSubscriber.php000077500000001057000000000000020006 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface BeforeTestMethodCalledSubscriber extends Subscriber { public function notify(BeforeTestMethodCalled $event): void; } Events/Test/HookMethod/BeforeFirstTestMethodErrored.php000077500000004052000000000000017206 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Code\Throwable; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class BeforeFirstTestMethodErrored implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; private readonly Code\ClassMethod $calledMethod; private readonly Throwable $throwable; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod $calledMethod, Throwable $throwable) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethod = $calledMethod; $this->throwable = $throwable; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } public function calledMethod(): Code\ClassMethod { return $this->calledMethod; } public function throwable(): Throwable { return $this->throwable; } public function asString(): string { $message = $this->throwable->message(); if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'Before First Test Method Errored (%s::%s)%s', $this->calledMethod->className(), $this->calledMethod->methodName(), $message, ); } } Events/Test/HookMethod/AfterLastTestMethodCalledSubscriber.php000077500000001065000000000000020470 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface AfterLastTestMethodCalledSubscriber extends Subscriber { public function notify(AfterLastTestMethodCalled $event): void; } Events/Test/HookMethod/AfterTestMethodCalled.php000077500000003225000000000000015620 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class AfterTestMethodCalled implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; private readonly Code\ClassMethod $calledMethod; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod $calledMethod) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethod = $calledMethod; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } public function calledMethod(): Code\ClassMethod { return $this->calledMethod; } public function asString(): string { return sprintf( 'After Test Method Called (%s::%s)', $this->calledMethod->className(), $this->calledMethod->methodName(), ); } } Events/Test/HookMethod/BeforeFirstTestMethodFinished.php000077500000003652000000000000017342 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class BeforeFirstTestMethodFinished implements Event { private readonly Telemetry\Info$telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; /** * @psalm-var list */ private readonly array $calledMethods; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod ...$calledMethods) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethods = $calledMethods; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } /** * @psalm-return list */ public function calledMethods(): array { return $this->calledMethods; } public function asString(): string { $buffer = 'Before First Test Method Finished:'; foreach ($this->calledMethods as $calledMethod) { $buffer .= sprintf( PHP_EOL . '- %s::%s', $calledMethod->className(), $calledMethod->methodName(), ); } return $buffer; } } Events/Test/HookMethod/PreConditionCalledSubscriber.php000077500000001047000000000000017177 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PreConditionCalledSubscriber extends Subscriber { public function notify(PreConditionCalled $event): void; } Events/Test/HookMethod/BeforeFirstTestMethodFinishedSubscriber.php000077500000001075000000000000021363 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface BeforeFirstTestMethodFinishedSubscriber extends Subscriber { public function notify(BeforeFirstTestMethodFinished $event): void; } Events/Test/HookMethod/BeforeFirstTestMethodCalled.php000077500000003242000000000000016770 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class BeforeFirstTestMethodCalled implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; private readonly Code\ClassMethod $calledMethod; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod $calledMethod) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethod = $calledMethod; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } public function calledMethod(): Code\ClassMethod { return $this->calledMethod; } public function asString(): string { return sprintf( 'Before First Test Method Called (%s::%s)', $this->calledMethod->className(), $this->calledMethod->methodName(), ); } } Events/Test/HookMethod/BeforeTestMethodCalled.php000077500000003227000000000000015763 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class BeforeTestMethodCalled implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; private readonly Code\ClassMethod $calledMethod; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod $calledMethod) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethod = $calledMethod; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } public function calledMethod(): Code\ClassMethod { return $this->calledMethod; } public function asString(): string { return sprintf( 'Before Test Method Called (%s::%s)', $this->calledMethod->className(), $this->calledMethod->methodName(), ); } } Events/Test/HookMethod/AfterLastTestMethodCalled.php000077500000003236000000000000016446 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class AfterLastTestMethodCalled implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; private readonly Code\ClassMethod $calledMethod; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod $calledMethod) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethod = $calledMethod; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } public function calledMethod(): Code\ClassMethod { return $this->calledMethod; } public function asString(): string { return sprintf( 'After Last Test Method Called (%s::%s)', $this->calledMethod->className(), $this->calledMethod->methodName(), ); } } Events/Test/HookMethod/BeforeFirstTestMethodCalledSubscriber.php000077500000001071000000000000021012 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface BeforeFirstTestMethodCalledSubscriber extends Subscriber { public function notify(BeforeFirstTestMethodCalled $event): void; } Events/Test/HookMethod/PreConditionFinished.php000077500000003636000000000000015526 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PreConditionFinished implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; /** * @psalm-var list */ private readonly array $calledMethods; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod ...$calledMethods) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethods = $calledMethods; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } /** * @psalm-return list */ public function calledMethods(): array { return $this->calledMethods; } public function asString(): string { $buffer = 'Pre Condition Method Finished:'; foreach ($this->calledMethods as $calledMethod) { $buffer .= sprintf( PHP_EOL . '- %s::%s', $calledMethod->className(), $calledMethod->methodName(), ); } return $buffer; } } Events/Test/HookMethod/PreConditionFinishedSubscriber.php000077500000001053000000000000017541 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PreConditionFinishedSubscriber extends Subscriber { public function notify(PreConditionFinished $event): void; } Events/Test/HookMethod/AfterLastTestMethodFinishedSubscriber.php000077500000001071000000000000021032 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface AfterLastTestMethodFinishedSubscriber extends Subscriber { public function notify(AfterLastTestMethodFinished $event): void; } Events/Test/HookMethod/PreConditionCalled.php000077500000003224000000000000015152 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PreConditionCalled implements Event { private readonly Telemetry\Info$telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; private readonly Code\ClassMethod $calledMethod; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod $calledMethod) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethod = $calledMethod; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } public function calledMethod(): Code\ClassMethod { return $this->calledMethod; } public function asString(): string { return sprintf( 'Pre Condition Method Called (%s::%s)', $this->calledMethod->className(), $this->calledMethod->methodName(), ); } } Events/Test/HookMethod/AfterTestMethodFinishedSubscriber.php000077500000001061000000000000020205 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface AfterTestMethodFinishedSubscriber extends Subscriber { public function notify(AfterTestMethodFinished $event): void; } Events/Test/HookMethod/PostConditionFinished.php000077500000003640000000000000015720 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PostConditionFinished implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $testClassName; /** * @psalm-var list */ private readonly array $calledMethods; /** * @psalm-param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod ...$calledMethods) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethods = $calledMethods; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function testClassName(): string { return $this->testClassName; } /** * @psalm-return list */ public function calledMethods(): array { return $this->calledMethods; } public function asString(): string { $buffer = 'Post Condition Method Finished:'; foreach ($this->calledMethods as $calledMethod) { $buffer .= sprintf( PHP_EOL . '- %s::%s', $calledMethod->className(), $calledMethod->methodName(), ); } return $buffer; } } Events/Test/HookMethod/PostConditionFinishedSubscriber.php000077500000001055000000000000017742 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PostConditionFinishedSubscriber extends Subscriber { public function notify(PostConditionFinished $event): void; } Events/Test/HookMethod/BeforeTestMethodFinishedSubscriber.php000077500000001063000000000000020350 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface BeforeTestMethodFinishedSubscriber extends Subscriber { public function notify(BeforeTestMethodFinished $event): void; } Events/Test/TestDouble/TestStubForIntersectionOfInterfacesCreatedSubscriber.php000077500000001127000000000000024101 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface TestStubForIntersectionOfInterfacesCreatedSubscriber extends Subscriber { public function notify(TestStubForIntersectionOfInterfacesCreated $event): void; } Events/Test/TestDouble/TestStubCreated.php000077500000002440000000000000014525 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestStubCreated implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @var class-string */ private readonly string $className; /** * @psalm-param class-string $className */ public function __construct(Telemetry\Info $telemetryInfo, string $className) { $this->telemetryInfo = $telemetryInfo; $this->className = $className; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @return class-string */ public function className(): string { return $this->className; } public function asString(): string { return sprintf( 'Test Stub Created (%s)', $this->className, ); } } Events/Test/TestDouble/MockObjectForIntersectionOfInterfacesCreatedSubscriber.php000077500000001133000000000000024341 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface MockObjectForIntersectionOfInterfacesCreatedSubscriber extends Subscriber { public function notify(MockObjectForIntersectionOfInterfacesCreated $event): void; } Events/Test/TestDouble/MockObjectForAbstractClassCreatedSubscriber.php000077500000001105000000000000022132 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface MockObjectForAbstractClassCreatedSubscriber extends Subscriber { public function notify(MockObjectForAbstractClassCreated $event): void; } Events/Test/TestDouble/TestProxyCreatedSubscriber.php000077500000001043000000000000016753 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface TestProxyCreatedSubscriber extends Subscriber { public function notify(TestProxyCreated $event): void; } Events/Test/TestDouble/TestProxyCreated.php000077500000003066000000000000014736 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestProxyCreated implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $className; private readonly string $constructorArguments; /** * @psalm-param class-string $className */ public function __construct(Telemetry\Info $telemetryInfo, string $className, string $constructorArguments) { $this->telemetryInfo = $telemetryInfo; $this->className = $className; $this->constructorArguments = $constructorArguments; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function className(): string { return $this->className; } public function constructorArguments(): string { return $this->constructorArguments; } public function asString(): string { return sprintf( 'Test Proxy Created (%s)', $this->className, ); } } Events/Test/TestDouble/MockObjectForAbstractClassCreated.php000077500000002500000000000000020106 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class MockObjectForAbstractClassCreated implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $className; /** * @psalm-param class-string $className */ public function __construct(Telemetry\Info $telemetryInfo, string $className) { $this->telemetryInfo = $telemetryInfo; $this->className = $className; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function className(): string { return $this->className; } public function asString(): string { return sprintf( 'Mock Object Created (%s)', $this->className, ); } } Events/Test/TestDouble/MockObjectForTraitCreated.php000077500000002470000000000000016446 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class MockObjectForTraitCreated implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var trait-string */ private readonly string $traitName; /** * @psalm-param trait-string $traitName */ public function __construct(Telemetry\Info $telemetryInfo, string $traitName) { $this->telemetryInfo = $telemetryInfo; $this->traitName = $traitName; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return trait-string */ public function traitName(): string { return $this->traitName; } public function asString(): string { return sprintf( 'Mock Object Created (%s)', $this->traitName, ); } } Events/Test/TestDouble/PartialMockObjectCreated.php000077500000003150000000000000016304 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PartialMockObjectCreated implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $className; /** * @psalm-var list */ private readonly array $methodNames; /** * @psalm-param class-string $className */ public function __construct(Telemetry\Info $telemetryInfo, string $className, string ...$methodNames) { $this->telemetryInfo = $telemetryInfo; $this->className = $className; $this->methodNames = $methodNames; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function className(): string { return $this->className; } /** * @psalm-return list */ public function methodNames(): array { return $this->methodNames; } public function asString(): string { return sprintf( 'Partial Mock Object Created (%s)', $this->className, ); } } Events/Test/TestDouble/MockObjectCreated.php000077500000002460000000000000014772 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class MockObjectCreated implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $className; /** * @psalm-param class-string $className */ public function __construct(Telemetry\Info $telemetryInfo, string $className) { $this->telemetryInfo = $telemetryInfo; $this->className = $className; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function className(): string { return $this->className; } public function asString(): string { return sprintf( 'Mock Object Created (%s)', $this->className, ); } } Events/Test/TestDouble/MockObjectFromWsdlCreated.php000077500000005202000000000000016445 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class MockObjectFromWsdlCreated implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly string $wsdlFile; /** * @psalm-var class-string */ private readonly string $originalClassName; /** * @psalm-var class-string */ private readonly string $mockClassName; /** * @psalm-var list */ private readonly array $methods; private readonly bool $callOriginalConstructor; private readonly array $options; /** * @psalm-param class-string $originalClassName * @psalm-param class-string $mockClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $wsdlFile, string $originalClassName, string $mockClassName, array $methods, bool $callOriginalConstructor, array $options) { $this->telemetryInfo = $telemetryInfo; $this->wsdlFile = $wsdlFile; $this->originalClassName = $originalClassName; $this->mockClassName = $mockClassName; $this->methods = $methods; $this->callOriginalConstructor = $callOriginalConstructor; $this->options = $options; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function wsdlFile(): string { return $this->wsdlFile; } /** * @psalm-return class-string */ public function originalClassName(): string { return $this->originalClassName; } /** * @psalm-return class-string */ public function mockClassName(): string { return $this->mockClassName; } /** * @psalm-return list */ public function methods(): array { return $this->methods; } public function callOriginalConstructor(): bool { return $this->callOriginalConstructor; } public function options(): array { return $this->options; } public function asString(): string { return sprintf( 'Mock Object Created (%s)', $this->wsdlFile, ); } } Events/Test/TestDouble/TestStubCreatedSubscriber.php000077500000001041000000000000016545 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface TestStubCreatedSubscriber extends Subscriber { public function notify(TestStubCreated $event): void; } Events/Test/TestDouble/PartialMockObjectCreatedSubscriber.php000077500000001063000000000000020331 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PartialMockObjectCreatedSubscriber extends Subscriber { public function notify(PartialMockObjectCreated $event): void; } Events/Test/TestDouble/MockObjectForTraitCreatedSubscriber.php000077500000001065000000000000020471 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface MockObjectForTraitCreatedSubscriber extends Subscriber { public function notify(MockObjectForTraitCreated $event): void; } Events/Test/TestDouble/MockObjectForIntersectionOfInterfacesCreated.php000077500000002577000000000000022332 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function implode; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class MockObjectForIntersectionOfInterfacesCreated implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var list */ private readonly array $interfaces; /** * @psalm-param list $interfaces */ public function __construct(Telemetry\Info $telemetryInfo, array $interfaces) { $this->telemetryInfo = $telemetryInfo; $this->interfaces = $interfaces; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @return list */ public function interfaces(): array { return $this->interfaces; } public function asString(): string { return sprintf( 'Mock Object Created (%s)', implode('&', $this->interfaces), ); } } Events/Test/TestDouble/TestStubForIntersectionOfInterfacesCreated.php000077500000002573000000000000022063 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function implode; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestStubForIntersectionOfInterfacesCreated implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var list */ private readonly array $interfaces; /** * @psalm-param list $interfaces */ public function __construct(Telemetry\Info $telemetryInfo, array $interfaces) { $this->telemetryInfo = $telemetryInfo; $this->interfaces = $interfaces; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @return list */ public function interfaces(): array { return $this->interfaces; } public function asString(): string { return sprintf( 'Test Stub Created (%s)', implode('&', $this->interfaces), ); } } Events/Test/TestDouble/MockObjectFromWsdlCreatedSubscriber.php000077500000001065000000000000020474 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface MockObjectFromWsdlCreatedSubscriber extends Subscriber { public function notify(MockObjectFromWsdlCreated $event): void; } Events/Test/TestDouble/MockObjectCreatedSubscriber.php000077500000001045000000000000017014 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface MockObjectCreatedSubscriber extends Subscriber { public function notify(MockObjectCreated $event): void; } Events/Test/ComparatorRegistered.php000077500000002465000000000000013542 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class ComparatorRegistered implements Event { private readonly Telemetry\Info $telemetryInfo; /** * @psalm-var class-string */ private readonly string $className; /** * @psalm-param class-string $className */ public function __construct(Telemetry\Info $telemetryInfo, string $className) { $this->telemetryInfo = $telemetryInfo; $this->className = $className; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @psalm-return class-string */ public function className(): string { return $this->className; } public function asString(): string { return sprintf( 'Comparator Registered (%s)', $this->className, ); } } Events/Test/PrintedUnexpectedOutputSubscriber.php000077500000001061000000000000016303 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PrintedUnexpectedOutputSubscriber extends Subscriber { public function notify(PrintedUnexpectedOutput $event): void; } Events/Test/Lifecycle/Prepared.php000077500000002214000000000000013046 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Prepared implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Code\Test $test; public function __construct(Telemetry\Info $telemetryInfo, Code\Test $test) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Code\Test { return $this->test; } public function asString(): string { return sprintf( 'Test Prepared (%s)', $this->test->id(), ); } } Events/Test/Lifecycle/PreparationFailedSubscriber.php000077500000001045000000000000016722 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PreparationFailedSubscriber extends Subscriber { public function notify(PreparationFailed $event): void; } Events/Test/Lifecycle/DataProviderMethodFinished.php000077500000003640000000000000016507 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Code\ClassMethod; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class DataProviderMethodFinished implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly ClassMethod $testMethod; /** * @psalm-var list */ private readonly array $calledMethods; public function __construct(Telemetry\Info $telemetryInfo, ClassMethod $testMethod, ClassMethod ...$calledMethods) { $this->telemetryInfo = $telemetryInfo; $this->testMethod = $testMethod; $this->calledMethods = $calledMethods; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function testMethod(): ClassMethod { return $this->testMethod; } /** * @psalm-return list */ public function calledMethods(): array { return $this->calledMethods; } public function asString(): string { $buffer = sprintf( 'Data Provider Method Finished for %s::%s:', $this->testMethod->className(), $this->testMethod->methodName(), ); foreach ($this->calledMethods as $calledMethod) { $buffer .= sprintf( PHP_EOL . '- %s::%s', $calledMethod->className(), $calledMethod->methodName(), ); } return $buffer; } } Events/Test/Lifecycle/DataProviderMethodCalled.php000077500000003206000000000000016140 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code\ClassMethod; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry\Info; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class DataProviderMethodCalled implements Event { private readonly Info $telemetryInfo; private readonly ClassMethod $testMethod; private readonly ClassMethod $dataProviderMethod; public function __construct(Info $telemetryInfo, ClassMethod $testMethod, ClassMethod $dataProviderMethod) { $this->telemetryInfo = $telemetryInfo; $this->testMethod = $testMethod; $this->dataProviderMethod = $dataProviderMethod; } public function telemetryInfo(): Info { return $this->telemetryInfo; } public function testMethod(): ClassMethod { return $this->testMethod; } public function dataProviderMethod(): ClassMethod { return $this->dataProviderMethod; } public function asString(): string { return sprintf( 'Data Provider Method Called (%s::%s for test method %s::%s)', $this->dataProviderMethod->className(), $this->dataProviderMethod->methodName(), $this->testMethod->className(), $this->testMethod->methodName(), ); } } Events/Test/Lifecycle/PreparationStartedSubscriber.php000077500000001047000000000000017146 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PreparationStartedSubscriber extends Subscriber { public function notify(PreparationStarted $event): void; } Events/Test/Lifecycle/DataProviderMethodCalledSubscriber.php000077500000001063000000000000020163 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface DataProviderMethodCalledSubscriber extends Subscriber { public function notify(DataProviderMethodCalled $event): void; } Events/Test/Lifecycle/PreparedSubscriber.php000077500000001023000000000000015067 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PreparedSubscriber extends Subscriber { public function notify(Prepared $event): void; } Events/Test/Lifecycle/DataProviderMethodFinishedSubscriber.php000077500000001067000000000000020534 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface DataProviderMethodFinishedSubscriber extends Subscriber { public function notify(DataProviderMethodFinished $event): void; } Events/Test/Lifecycle/PreparationFailed.php000077500000002237000000000000014702 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PreparationFailed implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Code\Test $test; public function __construct(Telemetry\Info $telemetryInfo, Code\Test $test) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Code\Test { return $this->test; } public function asString(): string { return sprintf( 'Test Preparation Failed (%s)', $this->test->id(), ); } } Events/Test/Lifecycle/PreparationStarted.php000077500000002241000000000000015117 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class PreparationStarted implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Code\Test $test; public function __construct(Telemetry\Info $telemetryInfo, Code\Test $test) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Code\Test { return $this->test; } public function asString(): string { return sprintf( 'Test Preparation Started (%s)', $this->test->id(), ); } } Events/Test/Lifecycle/Finished.php000077500000002703000000000000013040 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Finished implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Code\Test $test; private readonly int $numberOfAssertionsPerformed; public function __construct(Telemetry\Info $telemetryInfo, Code\Test $test, int $numberOfAssertionsPerformed) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->numberOfAssertionsPerformed = $numberOfAssertionsPerformed; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Code\Test { return $this->test; } public function numberOfAssertionsPerformed(): int { return $this->numberOfAssertionsPerformed; } public function asString(): string { return sprintf( 'Test Finished (%s)', $this->test->id(), ); } } Events/Test/Lifecycle/FinishedSubscriber.php000077500000001023000000000000015056 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface FinishedSubscriber extends Subscriber { public function notify(Finished $event): void; } Events/Test/Outcome/Failed.php000077500000004343000000000000012211 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use function trim; use PHPUnit\Event\Code; use PHPUnit\Event\Code\ComparisonFailure; use PHPUnit\Event\Code\Throwable; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Failed implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Code\Test $test; private readonly Throwable $throwable; private readonly ?ComparisonFailure $comparisonFailure; public function __construct(Telemetry\Info $telemetryInfo, Code\Test $test, Throwable $throwable, ?ComparisonFailure $comparisonFailure) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->throwable = $throwable; $this->comparisonFailure = $comparisonFailure; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Code\Test { return $this->test; } public function throwable(): Throwable { return $this->throwable; } /** * @psalm-assert-if-true !null $this->comparisonFailure */ public function hasComparisonFailure(): bool { return $this->comparisonFailure !== null; } /** * @throws NoComparisonFailureException */ public function comparisonFailure(): ComparisonFailure { if ($this->comparisonFailure === null) { throw new NoComparisonFailureException; } return $this->comparisonFailure; } public function asString(): string { $message = trim($this->throwable->message()); if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'Test Failed (%s)%s', $this->test->id(), $message, ); } } Events/Test/Outcome/MarkedIncomplete.php000077500000003117000000000000014246 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use function trim; use PHPUnit\Event\Code; use PHPUnit\Event\Code\Throwable; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class MarkedIncomplete implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Code\Test $test; private readonly Throwable $throwable; public function __construct(Telemetry\Info $telemetryInfo, Code\Test $test, Throwable $throwable) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->throwable = $throwable; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Code\Test { return $this->test; } public function throwable(): Throwable { return $this->throwable; } public function asString(): string { $message = trim($this->throwable->message()); if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'Test Marked Incomplete (%s)%s', $this->test->id(), $message, ); } } Events/Test/Outcome/FailedSubscriber.php000077500000001017000000000000014230 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface FailedSubscriber extends Subscriber { public function notify(Failed $event): void; } Events/Test/Outcome/Errored.php000077500000003074000000000000012427 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use function trim; use PHPUnit\Event\Code; use PHPUnit\Event\Code\Throwable; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Errored implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Code\Test $test; private readonly Throwable $throwable; public function __construct(Telemetry\Info $telemetryInfo, Code\Test $test, Throwable $throwable) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->throwable = $throwable; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Code\Test { return $this->test; } public function throwable(): Throwable { return $this->throwable; } public function asString(): string { $message = trim($this->throwable->message()); if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'Test Errored (%s)%s', $this->test->id(), $message, ); } } Events/Test/Outcome/Skipped.php000077500000002741000000000000012424 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Skipped implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Code\Test $test; private readonly string $message; public function __construct(Telemetry\Info $telemetryInfo, Code\Test $test, string $message) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; $this->message = $message; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Code\Test { return $this->test; } public function message(): string { return $this->message; } public function asString(): string { $message = $this->message; if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'Test Skipped (%s)%s', $this->test->id(), $message, ); } } Events/Test/Outcome/SkippedSubscriber.php000077500000001021000000000000014436 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface SkippedSubscriber extends Subscriber { public function notify(Skipped $event): void; } Events/Test/Outcome/Passed.php000077500000002210000000000000012233 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Passed implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Code\Test $test; public function __construct(Telemetry\Info $telemetryInfo, Code\Test $test) { $this->telemetryInfo = $telemetryInfo; $this->test = $test; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function test(): Code\Test { return $this->test; } public function asString(): string { return sprintf( 'Test Passed (%s)', $this->test->id(), ); } } Events/Test/Outcome/ErroredSubscriber.php000077500000001021000000000000014441 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface ErroredSubscriber extends Subscriber { public function notify(Errored $event): void; } Events/Test/Outcome/MarkedIncompleteSubscriber.php000077500000001043000000000000016266 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface MarkedIncompleteSubscriber extends Subscriber { public function notify(MarkedIncomplete $event): void; } Events/Test/Outcome/PassedSubscriber.php000077500000001017000000000000014263 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PassedSubscriber extends Subscriber { public function notify(Passed $event): void; } Events/Event.php000077500000000772000000000000007556 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface Event { public function telemetryInfo(): Telemetry\Info; public function asString(): string; } Events/Application/StartedSubscriber.php000077500000001030000000000000014356 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Application; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface StartedSubscriber extends Subscriber { public function notify(Started $event): void; } Events/Application/Started.php000077500000002261000000000000012341 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Application; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Runtime\Runtime; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Started implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly Runtime $runtime; public function __construct(Telemetry\Info $telemetryInfo, Runtime $runtime) { $this->telemetryInfo = $telemetryInfo; $this->runtime = $runtime; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function runtime(): Runtime { return $this->runtime; } public function asString(): string { return sprintf( 'PHPUnit Started (%s)', $this->runtime->asString(), ); } } Events/Application/Finished.php000077500000002255000000000000012467 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Application; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Finished implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly int $shellExitCode; public function __construct(Telemetry\Info $telemetryInfo, int $shellExitCode) { $this->telemetryInfo = $telemetryInfo; $this->shellExitCode = $shellExitCode; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function shellExitCode(): int { return $this->shellExitCode; } public function asString(): string { return sprintf( 'PHPUnit Finished (Shell Exit Code: %d)', $this->shellExitCode, ); } } Events/Application/FinishedSubscriber.php000077500000001032000000000000014503 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Application; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface FinishedSubscriber extends Subscriber { public function notify(Finished $event): void; } Events/TestSuite/Sorted.php000077500000003070000000000000011660 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Sorted implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly int $executionOrder; private readonly int $executionOrderDefects; private readonly bool $resolveDependencies; public function __construct(Telemetry\Info $telemetryInfo, int $executionOrder, int $executionOrderDefects, bool $resolveDependencies) { $this->telemetryInfo = $telemetryInfo; $this->executionOrder = $executionOrder; $this->executionOrderDefects = $executionOrderDefects; $this->resolveDependencies = $resolveDependencies; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function executionOrder(): int { return $this->executionOrder; } public function executionOrderDefects(): int { return $this->executionOrderDefects; } public function resolveDependencies(): bool { return $this->resolveDependencies; } public function asString(): string { return 'Test Suite Sorted'; } } Events/TestSuite/StartedSubscriber.php000077500000001026000000000000014051 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface StartedSubscriber extends Subscriber { public function notify(Started $event): void; } Events/TestSuite/FilteredSubscriber.php000077500000001030000000000000014174 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface FilteredSubscriber extends Subscriber { public function notify(Filtered $event): void; } Events/TestSuite/Skipped.php000077500000002557000000000000012030 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Skipped implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly TestSuite $testSuite; private readonly string $message; public function __construct(Telemetry\Info $telemetryInfo, TestSuite $testSuite, string $message) { $this->telemetryInfo = $telemetryInfo; $this->testSuite = $testSuite; $this->message = $message; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function testSuite(): TestSuite { return $this->testSuite; } public function message(): string { return $this->message; } public function asString(): string { return sprintf( 'Test Suite Skipped (%s, %s)', $this->testSuite->name(), $this->message, ); } } Events/TestSuite/SkippedSubscriber.php000077500000001026000000000000014042 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface SkippedSubscriber extends Subscriber { public function notify(Skipped $event): void; } Events/TestSuite/Filtered.php000077500000002337000000000000012163 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Filtered implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly TestSuite $testSuite; public function __construct(Telemetry\Info $telemetryInfo, TestSuite $testSuite) { $this->telemetryInfo = $telemetryInfo; $this->testSuite = $testSuite; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function testSuite(): TestSuite { return $this->testSuite; } public function asString(): string { return sprintf( 'Test Suite Filtered (%d test%s)', $this->testSuite->count(), $this->testSuite->count() !== 1 ? 's' : '', ); } } Events/TestSuite/Loaded.php000077500000002333000000000000011611 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Loaded implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly TestSuite $testSuite; public function __construct(Telemetry\Info $telemetryInfo, TestSuite $testSuite) { $this->telemetryInfo = $telemetryInfo; $this->testSuite = $testSuite; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function testSuite(): TestSuite { return $this->testSuite; } public function asString(): string { return sprintf( 'Test Suite Loaded (%d test%s)', $this->testSuite->count(), $this->testSuite->count() !== 1 ? 's' : '', ); } } Events/TestSuite/LoadedSubscriber.php000077500000001024000000000000013631 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface LoadedSubscriber extends Subscriber { public function notify(Loaded $event): void; } Events/TestSuite/SortedSubscriber.php000077500000001024000000000000013701 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface SortedSubscriber extends Subscriber { public function notify(Sorted $event): void; } Events/TestSuite/Started.php000077500000002407000000000000012031 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Started implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly TestSuite $testSuite; public function __construct(Telemetry\Info $telemetryInfo, TestSuite $testSuite) { $this->telemetryInfo = $telemetryInfo; $this->testSuite = $testSuite; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function testSuite(): TestSuite { return $this->testSuite; } public function asString(): string { return sprintf( 'Test Suite Started (%s, %d test%s)', $this->testSuite->name(), $this->testSuite->count(), $this->testSuite->count() !== 1 ? 's' : '', ); } } Events/TestSuite/Finished.php000077500000002411000000000000012147 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @psalm-immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class Finished implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly TestSuite $testSuite; public function __construct(Telemetry\Info $telemetryInfo, TestSuite $testSuite) { $this->telemetryInfo = $telemetryInfo; $this->testSuite = $testSuite; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function testSuite(): TestSuite { return $this->testSuite; } public function asString(): string { return sprintf( 'Test Suite Finished (%s, %d test%s)', $this->testSuite->name(), $this->testSuite->count(), $this->testSuite->count() !== 1 ? 's' : '', ); } } Events/TestSuite/FinishedSubscriber.php000077500000001030000000000000014167 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestSuite; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface FinishedSubscriber extends Subscriber { public function notify(Finished $event): void; } Events/EventCollection.php000077500000002441000000000000011565 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event; use function count; use Countable; use IteratorAggregate; /** * @template-implements IteratorAggregate * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class EventCollection implements Countable, IteratorAggregate { /** * @psalm-var list */ private array $events = []; public function add(Event ...$events): void { foreach ($events as $event) { $this->events[] = $event; } } /** * @psalm-return list */ public function asArray(): array { return $this->events; } public function count(): int { return count($this->events); } public function isEmpty(): bool { return $this->count() === 0; } public function isNotEmpty(): bool { return $this->count() > 0; } public function getIterator(): EventCollectionIterator { return new EventCollectionIterator($this); } } Exception/MoreThanOneDataSetFromDataProviderException.php000077500000001057000000000000017621 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestData; use PHPUnit\Event\Exception; use RuntimeException; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class MoreThanOneDataSetFromDataProviderException extends RuntimeException implements Exception { } Events/Test/Assertion/AssertionFailedSubscriber.php000077500000001063000000000000016455 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit * * @deprecated */ interface AssertionFailedSubscriber extends Subscriber { public function notify(AssertionFailed $event): void; } Events/Test/Assertion/AssertionSucceededSubscriber.php000077500000001071000000000000017154 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit * * @deprecated */ interface AssertionSucceededSubscriber extends Subscriber { public function notify(AssertionSucceeded $event): void; } Events/Test/Assertion/AssertionFailed.php000077500000003461000000000000014435 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit * * @deprecated */ final class AssertionFailed implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly string $value; private readonly string $constraint; private readonly int $count; private readonly string $message; public function __construct(Telemetry\Info $telemetryInfo, string $value, string $constraint, int $count, string $message) { $this->telemetryInfo = $telemetryInfo; $this->value = $value; $this->constraint = $constraint; $this->count = $count; $this->message = $message; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function value(): string { return $this->value; } public function count(): int { return $this->count; } public function message(): string { return $this->message; } public function asString(): string { $message = ''; if (!empty($this->message)) { $message = sprintf( ', Message: %s', $this->message, ); } return sprintf( 'Assertion Failed (Constraint: %s, Value: %s%s)', $this->constraint, $this->value, $message, ); } } Events/Test/Assertion/AssertionSucceeded.php000077500000003467000000000000015143 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use function sprintf; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit * * @deprecated */ final class AssertionSucceeded implements Event { private readonly Telemetry\Info $telemetryInfo; private readonly string $value; private readonly string $constraint; private readonly int $count; private readonly string $message; public function __construct(Telemetry\Info $telemetryInfo, string $value, string $constraint, int $count, string $message) { $this->telemetryInfo = $telemetryInfo; $this->value = $value; $this->constraint = $constraint; $this->count = $count; $this->message = $message; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function value(): string { return $this->value; } public function count(): int { return $this->count; } public function message(): string { return $this->message; } public function asString(): string { $message = ''; if (!empty($this->message)) { $message = sprintf( ', Message: %s', $this->message, ); } return sprintf( 'Assertion Succeeded (Constraint: %s, Value: %s%s)', $this->constraint, $this->value, $message, ); } } EventTypeCondition.php000077700000002023000000000000011014 0ustar00 * * Original code based on the Symfony EventDispatcher "Event" contract * - (c) 2018-2019 Fabien Potencier * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace League\CommonMark\Event; use Psr\EventDispatcher\StoppableEventInterface; /** * Base class for classes containing event data. * * This class contains no event data. It is used by events that do not pass * state information to an event handler when an event is raised. * * You can call the method stopPropagation() to abort the execution of * further listeners in your event listener. */ abstract class AbstractEvent implements StoppableEventInterface { /** @psalm-readonly-allow-private-mutation */ private bool $propagationStopped = false; /** * Returns whether further event listeners should be triggered. */ final public function isPropagationStopped(): bool { return $this->propagationStopped; } /** * Stops the propagation of the event to further event listeners. * * If multiple event listeners are connected to the same event, no * further event listener will be triggered once any trigger calls * stopPropagation(). */ final public function stopPropagation(): void { $this->propagationStopped = true; } } ListenerData.php000066400000001605000000000000007601 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace League\CommonMark\Event; /** * @internal * * @psalm-immutable */ final class ListenerData { /** @var class-string */ private string $event; /** @var callable */ private $listener; /** * @param class-string $event */ public function __construct(string $event, callable $listener) { $this->event = $event; $this->listener = $listener; } /** * @return class-string */ public function getEvent(): string { return $this->event; } public function getListener(): callable { return $this->listener; } } DocumentPreRenderEvent.php000066400000001616000000000000011613 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace League\CommonMark\Event; use League\CommonMark\Node\Block\Document; /** * Event dispatched just before rendering begins */ final class DocumentPreRenderEvent extends AbstractEvent { /** @psalm-readonly */ private Document $document; /** @psalm-readonly */ private string $format; public function __construct(Document $document, string $format) { $this->document = $document; $this->format = $format; } public function getDocument(): Document { return $this->document; } public function getFormat(): string { return $this->format; } } DocumentPreParsedEvent.php000066400000002164000000000000011611 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace League\CommonMark\Event; use League\CommonMark\Input\MarkdownInputInterface; use League\CommonMark\Node\Block\Document; /** * Event dispatched when the document is about to be parsed */ final class DocumentPreParsedEvent extends AbstractEvent { /** @psalm-readonly */ private Document $document; private MarkdownInputInterface $markdown; public function __construct(Document $document, MarkdownInputInterface $markdown) { $this->document = $document; $this->markdown = $markdown; } public function getDocument(): Document { return $this->document; } public function getMarkdown(): MarkdownInputInterface { return $this->markdown; } public function replaceMarkdown(MarkdownInputInterface $markdownInput): void { $this->markdown = $markdownInput; } } DocumentRenderedEvent.php000066400000001604000000000000011452 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ declare(strict_types=1); namespace League\CommonMark\Event; use League\CommonMark\Output\RenderedContentInterface; final class DocumentRenderedEvent extends AbstractEvent { private RenderedContentInterface $output; public function __construct(RenderedContentInterface $output) { $this->output = $output; } /** * @psalm-mutation-free */ public function getOutput(): RenderedContentInterface { return $this->output; } /** * @psalm-external-mutation-free */ public function replaceOutput(RenderedContentInterface $output): void { $this->output = $output; } } DocumentParsedEvent.php000066400000001330000000000000011134 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace League\CommonMark\Event; use League\CommonMark\Node\Block\Document; /** * Event dispatched when the document has been fully parsed */ final class DocumentParsedEvent extends AbstractEvent { /** @psalm-readonly */ private Document $document; public function __construct(Document $document) { $this->document = $document; } public function getDocument(): Document { return $this->document; } } FinishRequestEvent.php000077500000000705000000000000011020 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\HttpKernel\Event; /** * Triggered whenever a request is fully processed. * * @author Benjamin Eberlei */ final class FinishRequestEvent extends KernelEvent { } ResponseEvent.php000077500000002224000000000000010023 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\HttpKernel\Event; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\HttpFoundation\Response; use Symfony\Component\HttpKernel\HttpKernelInterface; /** * Allows to filter a Response object. * * You can call getResponse() to retrieve the current response. With * setResponse() you can set a new response that will be returned to the * browser. * * @author Bernhard Schussek */ final class ResponseEvent extends KernelEvent { public function __construct( HttpKernelInterface $kernel, Request $request, int $requestType, private Response $response, ) { parent::__construct($kernel, $request, $requestType); } public function getResponse(): Response { return $this->response; } public function setResponse(Response $response): void { $this->response = $response; } } RequestEvent.php000077500000002257000000000000007663 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\HttpKernel\Event; use Symfony\Component\HttpFoundation\Response; /** * Allows to create a response for a request. * * Call setResponse() to set the response that will be returned for the * current request. The propagation of this event is stopped as soon as a * response is set. * * @author Bernhard Schussek */ class RequestEvent extends KernelEvent { private ?Response $response = null; /** * Returns the response object. */ public function getResponse(): ?Response { return $this->response; } /** * Sets a response and stops event propagation. */ public function setResponse(Response $response): void { $this->response = $response; $this->stopPropagation(); } /** * Returns whether a response was set. */ public function hasResponse(): bool { return null !== $this->response; } } KernelEvent.php000077500000003366000000000000007455 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\HttpKernel\Event; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\HttpKernel\HttpKernelInterface; use Symfony\Contracts\EventDispatcher\Event; /** * Base class for events dispatched in the HttpKernel component. * * @author Bernhard Schussek */ class KernelEvent extends Event { /** * @param int $requestType The request type the kernel is currently processing; one of * HttpKernelInterface::MAIN_REQUEST or HttpKernelInterface::SUB_REQUEST */ public function __construct( private HttpKernelInterface $kernel, private Request $request, private ?int $requestType, ) { } /** * Returns the kernel in which this event was thrown. */ public function getKernel(): HttpKernelInterface { return $this->kernel; } /** * Returns the request the kernel is currently processing. */ public function getRequest(): Request { return $this->request; } /** * Returns the request type the kernel is currently processing. * * @return int One of HttpKernelInterface::MAIN_REQUEST and * HttpKernelInterface::SUB_REQUEST */ public function getRequestType(): int { return $this->requestType; } /** * Checks if this is the main request. */ public function isMainRequest(): bool { return HttpKernelInterface::MAIN_REQUEST === $this->requestType; } } ExceptionEvent.php000077500000004074000000000000010170 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\HttpKernel\Event; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\HttpKernel\HttpKernelInterface; /** * Allows to create a response for a thrown exception. * * Call setResponse() to set the response that will be returned for the * current request. The propagation of this event is stopped as soon as a * response is set. * * You can also call setThrowable() to replace the thrown exception. This * exception will be thrown if no response is set during processing of this * event. * * @author Bernhard Schussek */ final class ExceptionEvent extends RequestEvent { private \Throwable $throwable; private bool $allowCustomResponseCode = false; public function __construct( HttpKernelInterface $kernel, Request $request, int $requestType, \Throwable $e, private bool $isKernelTerminating = false, ) { parent::__construct($kernel, $request, $requestType); $this->setThrowable($e); } public function getThrowable(): \Throwable { return $this->throwable; } /** * Replaces the thrown exception. * * This exception will be thrown if no response is set in the event. */ public function setThrowable(\Throwable $exception): void { $this->throwable = $exception; } /** * Mark the event as allowing a custom response code. */ public function allowCustomResponseCode(): void { $this->allowCustomResponseCode = true; } /** * Returns true if the event allows a custom response code. */ public function isAllowingCustomResponseCode(): bool { return $this->allowCustomResponseCode; } public function isKernelTerminating(): bool { return $this->isKernelTerminating; } } ViewEvent.php000077500000002417000000000000007143 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\HttpKernel\Event; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\HttpKernel\HttpKernelInterface; /** * Allows to create a response for the return value of a controller. * * Call setResponse() to set the response that will be returned for the * current request. The propagation of this event is stopped as soon as a * response is set. * * @author Bernhard Schussek */ final class ViewEvent extends RequestEvent { public function __construct( HttpKernelInterface $kernel, Request $request, int $requestType, private mixed $controllerResult, public readonly ?ControllerArgumentsEvent $controllerArgumentsEvent = null, ) { parent::__construct($kernel, $request, $requestType); } public function getControllerResult(): mixed { return $this->controllerResult; } public function setControllerResult(mixed $controllerResult): void { $this->controllerResult = $controllerResult; } } ControllerEvent.php000077500000007427000000000000010362 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\HttpKernel\Event; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\HttpKernel\HttpKernelInterface; /** * Allows filtering of a controller callable. * * You can call getController() to retrieve the current controller. With * setController() you can set a new controller that is used in the processing * of the request. * * Controllers should be callables. * * @author Bernhard Schussek */ final class ControllerEvent extends KernelEvent { private string|array|object $controller; private \ReflectionFunctionAbstract $controllerReflector; private array $attributes; public function __construct(HttpKernelInterface $kernel, callable $controller, Request $request, ?int $requestType) { parent::__construct($kernel, $request, $requestType); $this->setController($controller); } public function getController(): callable { return $this->controller; } public function getControllerReflector(): \ReflectionFunctionAbstract { return $this->controllerReflector; } /** * @param array>|null $attributes */ public function setController(callable $controller, ?array $attributes = null): void { if (null !== $attributes) { $this->attributes = $attributes; } if (isset($this->controller) && ($controller instanceof \Closure ? $controller == $this->controller : $controller === $this->controller)) { $this->controller = $controller; return; } if (null === $attributes) { unset($this->attributes); } if (\is_array($controller) && method_exists(...$controller)) { $this->controllerReflector = new \ReflectionMethod(...$controller); } elseif (\is_string($controller) && str_contains($controller, '::')) { $this->controllerReflector = new \ReflectionMethod(...explode('::', $controller, 2)); } else { $this->controllerReflector = new \ReflectionFunction($controller(...)); } $this->controller = $controller; } /** * @template T of class-string|null * * @param T $className * * @return array>|list * * @psalm-return (T is null ? array> : list) */ public function getAttributes(?string $className = null): array { if (isset($this->attributes)) { return null === $className ? $this->attributes : $this->attributes[$className] ?? []; } if (\is_array($this->controller) && method_exists(...$this->controller)) { $class = new \ReflectionClass($this->controller[0]); } elseif (\is_string($this->controller) && false !== $i = strpos($this->controller, '::')) { $class = new \ReflectionClass(substr($this->controller, 0, $i)); } else { $class = $this->controllerReflector instanceof \ReflectionFunction && $this->controllerReflector->isAnonymous() ? null : $this->controllerReflector->getClosureCalledClass(); } $this->attributes = []; foreach (array_merge($class?->getAttributes() ?? [], $this->controllerReflector->getAttributes()) as $attribute) { if (class_exists($attribute->getName())) { $this->attributes[$attribute->getName()][] = $attribute->newInstance(); } } return null === $className ? $this->attributes : $this->attributes[$className] ?? []; } } ControllerArgumentsEvent.php000077500000006306000000000000012243 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\HttpKernel\Event; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\HttpKernel\HttpKernelInterface; /** * Allows filtering of controller arguments. * * You can call getController() to retrieve the controller and getArguments * to retrieve the current arguments. With setArguments() you can replace * arguments that are used to call the controller. * * Arguments set in the event must be compatible with the signature of the * controller. * * @author Christophe Coevoet */ final class ControllerArgumentsEvent extends KernelEvent { private ControllerEvent $controllerEvent; private array $namedArguments; public function __construct( HttpKernelInterface $kernel, callable|ControllerEvent $controller, private array $arguments, Request $request, ?int $requestType, ) { parent::__construct($kernel, $request, $requestType); if (!$controller instanceof ControllerEvent) { $controller = new ControllerEvent($kernel, $controller, $request, $requestType); } $this->controllerEvent = $controller; } public function getController(): callable { return $this->controllerEvent->getController(); } /** * @param array>|null $attributes */ public function setController(callable $controller, ?array $attributes = null): void { $this->controllerEvent->setController($controller, $attributes); unset($this->namedArguments); } public function getArguments(): array { return $this->arguments; } public function setArguments(array $arguments): void { $this->arguments = $arguments; unset($this->namedArguments); } public function getNamedArguments(): array { if (isset($this->namedArguments)) { return $this->namedArguments; } $namedArguments = []; $arguments = $this->arguments; foreach ($this->controllerEvent->getControllerReflector()->getParameters() as $i => $param) { if ($param->isVariadic()) { $namedArguments[$param->name] = \array_slice($arguments, $i); break; } if (\array_key_exists($i, $arguments)) { $namedArguments[$param->name] = $arguments[$i]; } elseif ($param->isDefaultvalueAvailable()) { $namedArguments[$param->name] = $param->getDefaultValue(); } } return $this->namedArguments = $namedArguments; } /** * @template T of class-string|null * * @param T $className * * @return array>|list * * @psalm-return (T is null ? array> : list) */ public function getAttributes(?string $className = null): array { return $this->controllerEvent->getAttributes($className); } } TerminateEvent.php000077500000002052000000000000010154 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace Symfony\Component\HttpKernel\Event; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\HttpFoundation\Response; use Symfony\Component\HttpKernel\HttpKernelInterface; /** * Allows to execute logic after a response was sent. * * Since it's only triggered on main requests, the `getRequestType()` method * will always return the value of `HttpKernelInterface::MAIN_REQUEST`. * * @author Jordi Boggiano */ final class TerminateEvent extends KernelEvent { public function __construct( HttpKernelInterface $kernel, Request $request, private Response $response, ) { parent::__construct($kernel, $request, HttpKernelInterface::MAIN_REQUEST); } public function getResponse(): Response { return $this->response; } } SchemaAlterTableRemoveColumnEventArgs.php000077700000003154000000000000014543 0ustar00column = $column; $this->tableDiff = $tableDiff; $this->platform = $platform; } /** @return Column */ public function getColumn() { return $this->column; } /** @return TableDiff */ public function getTableDiff() { return $this->tableDiff; } /** @return AbstractPlatform */ public function getPlatform() { return $this->platform; } /** * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead. * * @param string|string[] $sql * * @return SchemaAlterTableRemoveColumnEventArgs */ public function addSql($sql) { $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args()); return $this; } /** @return string[] */ public function getSql() { return $this->sql; } } SchemaAlterTableChangeColumnEventArgs.php000077700000003223000000000000014470 0ustar00columnDiff = $columnDiff; $this->tableDiff = $tableDiff; $this->platform = $platform; } /** @return ColumnDiff */ public function getColumnDiff() { return $this->columnDiff; } /** @return TableDiff */ public function getTableDiff() { return $this->tableDiff; } /** @return AbstractPlatform */ public function getPlatform() { return $this->platform; } /** * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead. * * @param string|string[] $sql * * @return SchemaAlterTableChangeColumnEventArgs */ public function addSql($sql) { $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args()); return $this; } /** @return string[] */ public function getSql() { return $this->sql; } } TransactionEventArgs.php000077700000000675000000000000011341 0ustar00connection = $connection; } public function getConnection(): Connection { return $this->connection; } } SchemaEventArgs.php000077700000000746000000000000010253 0ustar00preventDefault = true; return $this; } /** @return bool */ public function isDefaultPrevented() { return $this->preventDefault; } } SchemaColumnDefinitionEventArgs.php000077700000003413000000000000013434 0ustar00tableColumn = $tableColumn; $this->table = $table; $this->database = $database; $this->connection = $connection; } /** * Allows to clear the column which means the column will be excluded from * tables column list. * * @return SchemaColumnDefinitionEventArgs */ public function setColumn(?Column $column = null) { $this->column = $column; return $this; } /** @return Column|null */ public function getColumn() { return $this->column; } /** @return mixed[] */ public function getTableColumn() { return $this->tableColumn; } /** @return string */ public function getTable() { return $this->table; } /** @return string */ public function getDatabase() { return $this->database; } /** @return Connection */ public function getConnection() { return $this->connection; } } SchemaIndexDefinitionEventArgs.php000077700000003011000000000000013240 0ustar00tableIndex = $tableIndex; $this->table = $table; $this->connection = $connection; } /** * Allows to clear the index which means the index will be excluded from tables index list. * * @return SchemaIndexDefinitionEventArgs */ public function setIndex(?Index $index = null) { $this->index = $index; return $this; } /** @return Index|null */ public function getIndex() { return $this->index; } /** @return mixed[] */ public function getTableIndex() { return $this->tableIndex; } /** @return string */ public function getTable() { return $this->table; } /** @return Connection */ public function getConnection() { return $this->connection; } } Listeners/SQLiteSessionInit.php000077700000001272000000000000012530 0ustar00getConnection()->executeStatement('PRAGMA foreign_keys=ON'); } /** * {@inheritDoc} */ public function getSubscribedEvents() { return [Events::postConnect]; } } Listeners/OracleSessionInit.php000077700000004237000000000000012600 0ustar00 'HH24:MI:SS', 'NLS_DATE_FORMAT' => 'YYYY-MM-DD HH24:MI:SS', 'NLS_TIMESTAMP_FORMAT' => 'YYYY-MM-DD HH24:MI:SS', 'NLS_TIMESTAMP_TZ_FORMAT' => 'YYYY-MM-DD HH24:MI:SS TZH:TZM', 'NLS_NUMERIC_CHARACTERS' => '.,', ]; /** @param string[] $oracleSessionVars */ public function __construct(array $oracleSessionVars = []) { $this->_defaultSessionVars = array_merge($this->_defaultSessionVars, $oracleSessionVars); } /** * @return void * * @throws Exception */ public function postConnect(ConnectionEventArgs $args) { if (count($this->_defaultSessionVars) === 0) { return; } $vars = []; foreach (array_change_key_case($this->_defaultSessionVars, CASE_UPPER) as $option => $value) { if ($option === 'CURRENT_SCHEMA') { $vars[] = $option . ' = ' . $value; } else { $vars[] = $option . " = '" . $value . "'"; } } $sql = 'ALTER SESSION SET ' . implode(' ', $vars); $args->getConnection()->executeStatement($sql); } /** * {@inheritDoc} */ public function getSubscribedEvents() { return [Events::postConnect]; } } Listeners/SQLSessionInit.php000077700000001556000000000000012033 0ustar00sql = $sql; } /** * @return void * * @throws Exception */ public function postConnect(ConnectionEventArgs $args) { $args->getConnection()->executeStatement($this->sql); } /** * {@inheritDoc} */ public function getSubscribedEvents() { return [Events::postConnect]; } } ConnectionEventArgs.php000077700000001023000000000000011137 0ustar00connection = $connection; } /** @return Connection */ public function getConnection() { return $this->connection; } } SchemaCreateTableColumnEventArgs.php000077700000003073000000000000013521 0ustar00column = $column; $this->table = $table; $this->platform = $platform; } /** @return Column */ public function getColumn() { return $this->column; } /** @return Table */ public function getTable() { return $this->table; } /** @return AbstractPlatform */ public function getPlatform() { return $this->platform; } /** * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead. * * @param string|string[] $sql * * @return SchemaCreateTableColumnEventArgs */ public function addSql($sql) { $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args()); return $this; } /** @return string[] */ public function getSql() { return $this->sql; } } SchemaAlterTableAddColumnEventArgs.php000077700000004022000000000000013771 0ustar00column = $column; $this->tableDiff = $tableDiff; $this->platform = $platform; } /** @return Column */ public function getColumn() { return $this->column; } /** @return TableDiff */ public function getTableDiff() { return $this->tableDiff; } /** @return AbstractPlatform */ public function getPlatform() { return $this->platform; } /** * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead. * * @param string|string[] $sql * * @return SchemaAlterTableAddColumnEventArgs */ public function addSql($sql) { if (is_array($sql)) { Deprecation::trigger( 'doctrine/dbal', 'https://github.com/doctrine/dbal/issues/3580', 'Passing multiple SQL statements as an array to SchemaAlterTableAddColumnEventaArrgs::addSql() ' . 'is deprecated. Pass each statement as an individual argument instead.', ); } $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args()); return $this; } /** @return string[] */ public function getSql() { return $this->sql; } } SchemaAlterTableEventArgs.php000077700000002567000000000000012216 0ustar00tableDiff = $tableDiff; $this->platform = $platform; } /** @return TableDiff */ public function getTableDiff() { return $this->tableDiff; } /** @return AbstractPlatform */ public function getPlatform() { return $this->platform; } /** * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead. * * @param string|string[] $sql * * @return SchemaAlterTableEventArgs */ public function addSql($sql) { $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args()); return $this; } /** @return string[] */ public function getSql() { return $this->sql; } } TransactionCommitEventArgs.php000077700000000226000000000000012502 0ustar00table = $table; $this->platform = $platform; } /** @return string|Table */ public function getTable() { return $this->table; } /** @return AbstractPlatform */ public function getPlatform() { return $this->platform; } /** * @param string $sql * * @return SchemaDropTableEventArgs */ public function setSql($sql) { $this->sql = $sql; return $this; } /** @return string|null */ public function getSql() { return $this->sql; } } SchemaAlterTableRenameColumnEventArgs.php000077700000003606000000000000014517 0ustar00oldColumnName = $oldColumnName; $this->column = $column; $this->tableDiff = $tableDiff; $this->platform = $platform; } /** @return string */ public function getOldColumnName() { return $this->oldColumnName; } /** @return Column */ public function getColumn() { return $this->column; } /** @return TableDiff */ public function getTableDiff() { return $this->tableDiff; } /** @return AbstractPlatform */ public function getPlatform() { return $this->platform; } /** * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead. * * @param string|string[] $sql * * @return SchemaAlterTableRenameColumnEventArgs */ public function addSql($sql) { $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args()); return $this; } /** @return string[] */ public function getSql() { return $this->sql; } } SchemaCreateTableEventArgs.php000077700000003514000000000000012343 0ustar00table = $table; $this->columns = $columns; $this->options = $options; $this->platform = $platform; } /** @return Table */ public function getTable() { return $this->table; } /** @return mixed[][] */ public function getColumns() { return $this->columns; } /** @return mixed[] */ public function getOptions() { return $this->options; } /** @return AbstractPlatform */ public function getPlatform() { return $this->platform; } /** * Passing multiple SQL statements as an array is deprecated. Pass each statement as an individual argument instead. * * @param string|string[] $sql * * @return SchemaCreateTableEventArgs */ public function addSql($sql) { $this->sql = array_merge($this->sql, is_array($sql) ? $sql : func_get_args()); return $this; } /** @return string[] */ public function getSql() { return $this->sql; } } TransactionBeginEventArgs.php000077700000000225000000000000012275 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Code\IssueTrigger; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final class TestTrigger extends IssueTrigger { /** * Your test code triggers an issue. */ public function isTest(): true { return true; } public function asString(): string { return 'issue triggered by test code'; } } Events/TestRunner/ChildProcessFinishedSubscriber.php000064400000001061000000000000016651 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface ChildProcessFinishedSubscriber extends Subscriber { public function notify(ChildProcessFinished $event): void; } Events/TestRunner/ChildProcessStarted.php000064400000001601000000000000014502 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final readonly class ChildProcessStarted implements Event { private Telemetry\Info $telemetryInfo; public function __construct(Telemetry\Info $telemetryInfo) { $this->telemetryInfo = $telemetryInfo; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function asString(): string { return 'Child Process Started'; } } Events/TestRunner/ChildProcessFinished.php000064400000002313000000000000014626 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final readonly class ChildProcessFinished implements Event { private Telemetry\Info $telemetryInfo; private string $stdout; private string $stderr; public function __construct(Telemetry\Info $telemetryInfo, string $stdout, string $stderr) { $this->telemetryInfo = $telemetryInfo; $this->stdout = $stdout; $this->stderr = $stderr; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } public function stdout(): string { return $this->stdout; } public function stderr(): string { return $this->stderr; } public function asString(): string { return 'Child Process Finished'; } } Events/TestRunner/ChildProcessStartedSubscriber.php000064400000001057000000000000016533 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\TestRunner; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface ChildProcessStartedSubscriber extends Subscriber { public function notify(ChildProcessStarted $event): void; } Events/Test/HookMethod/AfterLastTestMethodErroredSubscriber.php000064400000001067000000000000020703 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface AfterLastTestMethodErroredSubscriber extends Subscriber { public function notify(AfterLastTestMethodErrored $event): void; } Events/Test/HookMethod/AfterLastTestMethodErrored.php000064400000004006000000000000016653 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Code\Throwable; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final readonly class AfterLastTestMethodErrored implements Event { private Telemetry\Info $telemetryInfo; /** * @var class-string */ private string $testClassName; private Code\ClassMethod $calledMethod; private Throwable $throwable; /** * @param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod $calledMethod, Throwable $throwable) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethod = $calledMethod; $this->throwable = $throwable; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @return class-string */ public function testClassName(): string { return $this->testClassName; } public function calledMethod(): Code\ClassMethod { return $this->calledMethod; } public function throwable(): Throwable { return $this->throwable; } public function asString(): string { $message = $this->throwable->message(); if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'After Last Test Method Errored (%s::%s)%s', $this->calledMethod->className(), $this->calledMethod->methodName(), $message, ); } } Events/Test/HookMethod/PostConditionErrored.php000064400000003777000000000000015577 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Code\Throwable; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final readonly class PostConditionErrored implements Event { private Telemetry\Info $telemetryInfo; /** * @var class-string */ private string $testClassName; private Code\ClassMethod $calledMethod; private Throwable $throwable; /** * @param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod $calledMethod, Throwable $throwable) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethod = $calledMethod; $this->throwable = $throwable; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @return class-string */ public function testClassName(): string { return $this->testClassName; } public function calledMethod(): Code\ClassMethod { return $this->calledMethod; } public function throwable(): Throwable { return $this->throwable; } public function asString(): string { $message = $this->throwable->message(); if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'Post Condition Method Errored (%s::%s)%s', $this->calledMethod->className(), $this->calledMethod->methodName(), $message, ); } } Events/Test/HookMethod/BeforeTestMethodErroredSubscriber.php000064400000001061000000000000020212 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface BeforeTestMethodErroredSubscriber extends Subscriber { public function notify(BeforeTestMethodErrored $event): void; } Events/Test/HookMethod/PreConditionErroredSubscriber.php000064400000001051000000000000017403 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PreConditionErroredSubscriber extends Subscriber { public function notify(PreConditionErrored $event): void; } Events/Test/HookMethod/AfterTestMethodErroredSubscriber.php000064400000001057000000000000020056 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface AfterTestMethodErroredSubscriber extends Subscriber { public function notify(AfterTestMethodErrored $event): void; } Events/Test/HookMethod/AfterTestMethodErrored.php000064400000003775000000000000016043 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Code\Throwable; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final readonly class AfterTestMethodErrored implements Event { private Telemetry\Info $telemetryInfo; /** * @var class-string */ private string $testClassName; private Code\ClassMethod $calledMethod; private Throwable $throwable; /** * @param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod $calledMethod, Throwable $throwable) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethod = $calledMethod; $this->throwable = $throwable; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @return class-string */ public function testClassName(): string { return $this->testClassName; } public function calledMethod(): Code\ClassMethod { return $this->calledMethod; } public function throwable(): Throwable { return $this->throwable; } public function asString(): string { $message = $this->throwable->message(); if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'After Test Method Errored (%s::%s)%s', $this->calledMethod->className(), $this->calledMethod->methodName(), $message, ); } } Events/Test/HookMethod/PreConditionErrored.php000064400000003775000000000000015376 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Code\Throwable; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final readonly class PreConditionErrored implements Event { private Telemetry\Info $telemetryInfo; /** * @var class-string */ private string $testClassName; private Code\ClassMethod $calledMethod; private Throwable $throwable; /** * @param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod $calledMethod, Throwable $throwable) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethod = $calledMethod; $this->throwable = $throwable; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @return class-string */ public function testClassName(): string { return $this->testClassName; } public function calledMethod(): Code\ClassMethod { return $this->calledMethod; } public function throwable(): Throwable { return $this->throwable; } public function asString(): string { $message = $this->throwable->message(); if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'Pre Condition Method Errored (%s::%s)%s', $this->calledMethod->className(), $this->calledMethod->methodName(), $message, ); } } Events/Test/HookMethod/PostConditionErroredSubscriber.php000064400000001053000000000000017604 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use PHPUnit\Event\Subscriber; /** * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ interface PostConditionErroredSubscriber extends Subscriber { public function notify(PostConditionErrored $event): void; } Events/Test/HookMethod/BeforeTestMethodErrored.php000064400000003777000000000000016206 0ustar00 * * For the full copyright and license information, please view the LICENSE * file that was distributed with this source code. */ namespace PHPUnit\Event\Test; use const PHP_EOL; use function sprintf; use PHPUnit\Event\Code; use PHPUnit\Event\Code\Throwable; use PHPUnit\Event\Event; use PHPUnit\Event\Telemetry; /** * @immutable * * @no-named-arguments Parameter names are not covered by the backward compatibility promise for PHPUnit */ final readonly class BeforeTestMethodErrored implements Event { private Telemetry\Info $telemetryInfo; /** * @var class-string */ private string $testClassName; private Code\ClassMethod $calledMethod; private Throwable $throwable; /** * @param class-string $testClassName */ public function __construct(Telemetry\Info $telemetryInfo, string $testClassName, Code\ClassMethod $calledMethod, Throwable $throwable) { $this->telemetryInfo = $telemetryInfo; $this->testClassName = $testClassName; $this->calledMethod = $calledMethod; $this->throwable = $throwable; } public function telemetryInfo(): Telemetry\Info { return $this->telemetryInfo; } /** * @return class-string */ public function testClassName(): string { return $this->testClassName; } public function calledMethod(): Code\ClassMethod { return $this->calledMethod; } public function throwable(): Throwable { return $this->throwable; } public function asString(): string { $message = $this->throwable->message(); if (!empty($message)) { $message = PHP_EOL . $message; } return sprintf( 'Before Test Method Errored (%s::%s)%s', $this->calledMethod->className(), $this->calledMethod->methodName(), $message, ); } }