blib/lib/Linux/Event/Kernel/Process.pm

filter: Statementstmt 84.1% 420 / 499 Branchbran 68.1% 210 / 308 Conditioncond 48.1% 104 / 216 MC/DCmcdc 21.9% 27 / 123 Subroutinesub 89.8% 53 / 59 Podpod 83.3% 15 / 18 totaltotal 67.7% 829 / 1223 CC 242 SCAR 33.0
CC
242
Cov
72%
spawn
88.3
_attach_to_loop
47.8
_fork_preflight
30.0
CRAP 27.1
« bench/run-stream-payload-sweep.pl ↑ Summary blib/lib/Linux/Event/_Socket/Stream.pm »
1 package Linux::Event::Kernel::Process;
2 13 ▶use v5.36;
Subroutine BEGIN: called CC=1 SCAR=0.0
3 13 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 13 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
5  
6 13 our $VERSION = '0.120';
7  
8 13 ▶use Carp qw(croak);
Subroutine BEGIN: called CC=1 SCAR=0.0
9 13 ▶use Errno ();
Subroutine BEGIN: called CC=1 SCAR=0.0
10 13 ▶use Fcntl qw(F_GETFD F_GETFL F_SETFD F_SETFL FD_CLOEXEC O_NONBLOCK);
Subroutine BEGIN: called CC=1 SCAR=0.0
11 13 ▶use POSIX qw(SIGKILL SIGRTMAX);
Subroutine BEGIN: called CC=1 SCAR=0.0
12 13 ▶use Scalar::Util qw(blessed);
Subroutine BEGIN: called CC=1 SCAR=0.0
13 13 ▶use utf8 ();
Subroutine BEGIN: called CC=1 SCAR=0.0
14  
15 13 require Linux::Event::Loop;
16 13 ▶use Linux::Event::Error;
Subroutine BEGIN: called CC=1 SCAR=0.0
17 13 require XSLoader;
18 13 XSLoader::load(__PACKAGE__, $VERSION);
19  
20 13 my %CLASS_DESCRIPTOR;
21 13 my @CALLBACK = qw(
22 on_exit on_stdout on_stderr on_stdout_eof on_stderr_eof
23 on_stdin_drain on_error
24 );
25 # Private control retained only for the paired pipe-drain benchmark.
26 13 our $_PIPE_DRAIN_ENGINE = 'native';
27  
28 253 ▶sub _integer ($target, $name, $value, $minimum, $maximum = 2_147_483_647) {
Subroutine _integer: called CC=9 SCAR=25.1
29 253 ▶ croak "$target $name must be an integer"
Branch: 1 branch
BranchTrueFalseTotal
if not defined $value or ref $value or not $value =~ /\A\d+\z/u 0 253 253
Condition33%2/6
not defined $value or ref $value or not $value =~ /\A\d+\z/u
l!l&&r!l&&!r
00253
not defined $value or ref $value
l!l&&r!l&&!r
00253
MC/DC0%0/3
not defined $value or ref $value or not $value =~ /\A\d+\z/u
not defined $value ref $value not $value =~ /\A\d+\z/u
Truth table25%1/4
not(A) or B or not(C)
A= not defined $valueB= ref $valueC= not $value =~ /\A\d+\z/u
ABCresult
1XX1
01X1
0011
0000
30 if !defined($value) || ref($value) || $value !~ /\A\d+\z/;
31 253 my $digits = "$value";
32 253 $digits =~ s/\A0+(?=\d)//;
33 253 ▶ croak "$target $name must be at most $maximum"
Branch: 1 branch
BranchTrueFalseTotal
if length $digits > length "$maximum" or length $digits == length "$maximum" and $digits gt "$maximum" 1 252 253
Condition50%3/6
length $digits > length "$maximum" or length $digits == length "$maximum" and $digits gt "$maximum"
l!l&&r!l&&!r
10252
length $digits == length "$maximum" and $digits gt "$maximum"
!ll&&!rl&&r
25200
MC/DC33%1/3
length $digits > length "$maximum" or length $digits == length "$maximum" and $digits gt "$maximum"
length $digits > length "$maximum" length $digits == length "$maximum" $digits gt "$maximum"
Truth table50%2/4
A or B and C
A= length $digits > length "$maximum"B= length $digits == length "$maximum"C= $digits gt "$maximum"
ABCresult
1XX1
0111
00X0
0100
34 if length($digits) > length("$maximum")
35 || (length($digits) == length("$maximum")
36 && $digits gt "$maximum");
37 252 $value = 0 + $value;
38 252 ▶ croak "$target $name must be at least $minimum" if $value < $minimum;
Branch: 1 branch
BranchTrueFalseTotal
if $value < $minimum 0 252 252
39 252 return $value;
40 }
41  
42 44 ▶sub _descriptor_for ($class) {
Subroutine _descriptor_for: called CC=10 SCAR=24.1
43 44 ▶ return $CLASS_DESCRIPTOR{$class} if exists $CLASS_DESCRIPTOR{$class};
Branch: 1 branch
BranchTrueFalseTotal
if exists $CLASS_DESCRIPTOR{$class} 26 18 44
44 18 ▶ croak "$class is not a Linux::Event::Kernel::Process subclass"
Branch: 1 branch
BranchTrueFalseTotal
unless $class->isa(__PACKAGE__) 0 18 18
45 if !$class->isa(__PACKAGE__);
46 18 my %callback = map { $_ => scalar $class->can($_) } @CALLBACK;
47 18 my %option = (
48 read_size => 65_536,
49 max_reads_per_tick => 64,
50 stdin_high_watermark => 1_048_576,
51 stdin_low_watermark => 262_144,
52 max_pending_stdin => 0,
53 );
54 18 ▶ if (my $configure = $class->can('process_options')) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $configure = $class->can("process_options")) 1 17 18
55 1 my @configured = $configure->($class);
56 1 my %configured;
57 1 ▶ if (@configured == 1 && ref($configured[0]) eq 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if (@configured == 1 and ref $configured[0] eq 'HASH') { } 0 1 1
Condition33%1/3
@configured == 1 and ref $configured[0] eq "HASH"
!ll&&!rl&&r
100
MC/DC0%0/2
@configured == 1 and ref $configured[0] eq "HASH"
@configured == 1 ref $configured[0] eq "HASH"
Truth table33%1/3
A and B
A= @configured == 1B= ref $configured[0] eq "HASH"
ABresult
0X0
100
111
58 0 %configured = %{ $configured[0] };
59 } else {
60 1 ▶ croak "$class process_options() returned an odd option list"
Branch: 1 branch
BranchTrueFalseTotal
if @configured % 2 0 1 1
61 if @configured % 2;
62 1 %configured = @configured;
63 }
64 1 my @unknown = grep { !exists $option{$_} } keys %configured;
65 1 ▶ croak "$class process_options() returned unknown options: "
Branch: 1 branch
BranchTrueFalseTotal
if @unknown 0 1 1
66 . join(', ', sort @unknown) if @unknown;
67 1 @option{keys %configured} = values %configured;
68 }
69 18 $option{read_size} = _integer($class, 'read_size', $option{read_size}, 1);
70 $option{max_reads_per_tick} = _integer(
71 18 $class, 'max_reads_per_tick', $option{max_reads_per_tick}, 1,
72 );
73 18 for my $name (qw(stdin_high_watermark stdin_low_watermark
74 max_pending_stdin)) {
75 54 $option{$name} = _integer($class, $name, $option{$name}, 0);
76 }
77 croak "$class stdin_low_watermark must be <= stdin_high_watermark"
78 18 ▶ if $option{stdin_low_watermark} > $option{stdin_high_watermark};
Branch: 1 branch
BranchTrueFalseTotal
if $option{"stdin_low_watermark"} > $option{"stdin_high_watermark"} 0 18 18
79 18 return $CLASS_DESCRIPTOR{$class} = {
80 class => $class, callbacks => \%callback, options => \%option,
81 };
82 }
83  
84 44 ▶sub _effective_descriptor ($class, $method, $option) {
Subroutine _effective_descriptor: called CC=6 SCAR=17.9
85 44 my $descriptor = _descriptor_for($class);
86 44 my %override;
87 44 for my $name (@CALLBACK) {
88 302 ▶ next if !exists $option->{$name};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $option->{$name} 296 6 302
89 6 my $callback = delete $option->{$name};
90 6 ▶ croak "$method(): $name must be a coderef"
Branch: 1 branch
BranchTrueFalseTotal
if ref $callback ne "CODE" 1 5 6
91 if ref($callback) ne 'CODE';
92 5 $override{$name} = $callback;
93 }
94 43 my %callback = (%{ $descriptor->{callbacks} }, %override);
95 croak "$method(): on_exit callback is required"
96 43 ▶ if !$callback{on_exit};
Branch: 1 branch
BranchTrueFalseTotal
unless $callback{"on_exit"} 2 41 43
97 41 ▶ return $descriptor if !%override;
Branch: 1 branch
BranchTrueFalseTotal
unless %override 38 3 41
98 3 return { %$descriptor, callbacks => \%callback };
99 }
100  
101 7 ▶sub new ($class, %option) {
Subroutine new: called CC=15 SCAR=32.4
Pod undocumented
102 7 ▶ croak 'new(): must be called as a class method' if ref $class;
Branch: 1 branch
BranchTrueFalseTotal
if ref $class 0 7 7
103 7 my $descriptor = _effective_descriptor($class, 'new', \%option);
104 4 my $loop = delete $option{loop};
105 4 ▶ croak 'new(): loop must be an object implementing add() and watch()'
Branch: 1 branch
BranchTrueFalseTotal
if defined $loop and not ref $loop && $loop->can("add") && $loop->can("watch") 0 4 4
Condition11%1/9
defined $loop and not ref $loop && $loop->can("add") && $loop->can("watch")
!ll&&!rl&&r
400
ref $loop && $loop->can('add') && $loop->can('watch')
!ll&&!rl&&r
000
ref $loop and $loop->can("add")
!ll&&!rl&&r
000
MC/DC0%0/4
defined $loop and not ref $loop && $loop->can("add") && $loop->can("watch")
defined $loop ref $loop $loop->can("add") $loop->can('watch')
Truth table20%1/5
A and not(B and C && D)
A= defined $loopB= ref $loopC= $loop->can("add")D= $loop->can('watch')
ABCDresult
0XXX0
11110
10XX1
110X1
11101
106 if defined($loop) && (!ref($loop) || !$loop->can('add')
107 || !$loop->can('watch'));
108 4 my $data = delete $option{data};
109 4 my $pid = delete $option{pid};
110 4 ▶ croak 'new(): pid is required' if !defined $pid;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $pid 1 3 4
111 3 $pid = _integer('new():', 'pid', $pid, 1);
112 2 ▶ my $reap = exists($option{reap}) ? delete($option{reap}) : 1;
Branch: 1 branch
BranchTrueFalseTotal
exists $option{'reap'} ? : 1 1 2
113 2 ▶ croak 'new(): reap must be zero or one'
Branch: 1 branch
BranchTrueFalseTotal
if not defined $reap or ref $reap or not $reap =~ /\A[01]\z/u 0 2 2
Condition33%2/6
not defined $reap or ref $reap or not $reap =~ /\A[01]\z/u
l!l&&r!l&&!r
002
not defined $reap or ref $reap
l!l&&r!l&&!r
002
MC/DC0%0/3
not defined $reap or ref $reap or not $reap =~ /\A[01]\z/u
not defined $reap ref $reap not $reap =~ /\A[01]\z/u
Truth table25%1/4
not(A) or B or not(C)
A= not defined $reapB= ref $reapC= not $reap =~ /\A[01]\z/u
ABCresult
1XX1
01X1
0011
0000
114 if !defined($reap) || ref($reap) || $reap !~ /\A[01]\z/;
115 2 my $callback = $descriptor->{callbacks};
116 2 for my $name (qw(
117 on_stdout on_stderr on_stdout_eof on_stderr_eof on_stdin_drain
118 )) {
119 croak "new(): $name is unavailable when observing an existing process"
120 6 ▶ if $callback->{$name};
Branch: 1 branch
BranchTrueFalseTotal
if $callback->{$name} 1 5 6
121 }
122 1 ▶ croak 'new(): unknown options: ' . join(', ', sort keys %option)
Branch: 1 branch
BranchTrueFalseTotal
if %option 0 1 1
123 if %option;
124 1 ▶ my $self = $class->_new_object(
Branch: 1 branch
BranchTrueFalseTotal
$reap ? : 1 0 1
125 descriptor => $descriptor, loop => $loop, data => $data,
126 mode => 'observe', pid => $pid, reap => $reap ? 1 : 0,
127 );
128 1 return $self;
129 }
130  
131 37 ▶sub spawn ($class, %option) {
Subroutine spawn: called CC=48 SCAR=44.8
Pod undocumented
132 37 ▶ croak 'spawn(): must be called as a class method' if ref $class;
Branch: 1 branch
BranchTrueFalseTotal
if ref $class 0 37 37
133 37 my $descriptor = _effective_descriptor($class, 'spawn', \%option);
134 37 my $loop = delete $option{loop};
135 37 ▶ croak 'spawn(): loop must be an object implementing add() and watch()'
Branch: 1 branch
BranchTrueFalseTotal
if defined $loop and not ref $loop && $loop->can("add") && $loop->can("watch") 0 37 37
Condition44%4/9
defined $loop and not ref $loop && $loop->can("add") && $loop->can("watch")
!ll&&!rl&&r
3430
ref $loop && $loop->can('add') && $loop->can('watch')
!ll&&!rl&&r
003
ref $loop and $loop->can("add")
!ll&&!rl&&r
003
MC/DC0%0/4
defined $loop and not ref $loop && $loop->can("add") && $loop->can("watch")
defined $loop ref $loop $loop->can("add") $loop->can('watch')
Truth table40%2/5
A and not(B and C && D)
A= defined $loopB= ref $loopC= $loop->can("add")D= $loop->can('watch')
ABCDresult
0XXX0
11110
10XX1
110X1
11101
136 if defined($loop) && (!ref($loop) || !$loop->can('add')
137 || !$loop->can('watch'));
138 37 my $data = delete $option{data};
139 37 my $command = delete $option{command};
140 37 ▶ croak 'spawn(): command must be a nonempty array reference'
Branch: 1 branch
BranchTrueFalseTotal
if ref $command ne "ARRAY" or not @$command 2 35 37
Condition100%3/3
ref $command ne "ARRAY" or not @$command
l!l&&r!l&&!r
1135
MC/DC100%2/2
ref $command ne "ARRAY" or not @$command
ref $command ne "ARRAY" not @$command
Truth table100%3/3
A or not(B)
A= ref $command ne "ARRAY"B= not @$command
ABresult
1X1
011
000
141 if ref($command) ne 'ARRAY' || !@$command;
142 35 my @command;
143 35 for my $index (0 .. $#$command) {
144 82 my $argument = $command->[$index];
145 82 ▶ croak 'spawn(): every command argument must be a defined scalar'
Branch: 1 branch
BranchTrueFalseTotal
if not defined $argument or ref $argument 0 82 82
Condition33%1/3
not defined $argument or ref $argument
l!l&&r!l&&!r
0082
MC/DC0%0/2
not defined $argument or ref $argument
not defined $argument ref $argument
Truth table33%1/3
not(A) or B
A= not defined $argumentB= ref $argument
ABresult
1X1
011
000
146 if !defined($argument) || ref($argument);
147 82 ▶ croak 'spawn(): command arguments cannot contain NUL bytes'
Branch: 1 branch
BranchTrueFalseTotal
if "$argument" =~ /\0/u 0 82 82
148 if "$argument" =~ /\0/;
149 82 my $bytes = "$argument";
150 82 ▶ croak 'spawn(): command arguments must be byte strings'
Branch: 1 branch
BranchTrueFalseTotal
unless utf8::downgrade($bytes, 1) 1 81 82
151 if !utf8::downgrade($bytes, 1);
152 81 ▶ croak 'spawn(): command executable must be a non-empty string'
Branch: 1 branch
BranchTrueFalseTotal
if $index == 0 and $bytes eq "" 1 80 81
Condition100%3/3
$index == 0 and $bytes eq ""
!ll&&!rl&&r
47331
MC/DC100%2/2
$index == 0 and $bytes eq ""
$index == 0 $bytes eq ""
Truth table100%3/3
A and B
A= $index == 0B= $bytes eq ""
ABresult
0X0
100
111
153 if $index == 0 && $bytes eq '';
154 80 push @command, $bytes;
155 }
156 33 my $cwd = delete $option{cwd};
157 33 ▶ croak 'spawn(): cwd must be a non-empty path'
Branch: 1 branch
BranchTrueFalseTotal
if defined $cwd and ref $cwd || $cwd eq "" || $cwd =~ /\0/u 0 33 33
Condition44%4/9
defined $cwd and ref $cwd || $cwd eq "" || $cwd =~ /\0/u
!ll&&!rl&&r
3210
ref $cwd or $cwd eq "" or $cwd =~ /\0/u
l!l&&r!l&&!r
001
ref $cwd or $cwd eq ""
l!l&&r!l&&!r
001
MC/DC0%0/4
defined $cwd and ref $cwd || $cwd eq "" || $cwd =~ /\0/u
defined $cwd ref $cwd $cwd eq "" $cwd =~ /\0/u
Truth table40%2/5
A and B or C or D
A= defined $cwdB= ref $cwdC= $cwd eq ""D= $cwd =~ /\0/u
ABCDresult
0XXX0
10000
11XX1
101X1
10011
158 if defined($cwd) && (ref($cwd) || $cwd eq '' || $cwd =~ /\0/);
159 33 ▶ if (defined $cwd) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $cwd) 1 32 33
160 1 $cwd = "$cwd";
161 1 ▶ croak 'spawn(): cwd must be a byte-string path'
Branch: 1 branch
BranchTrueFalseTotal
unless utf8::downgrade($cwd, 1) 0 1 1
162 if !utf8::downgrade($cwd, 1);
163 }
164 33 my $env = delete $option{env};
165 33 ▶ if (defined $env) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $env) 2 31 33
166 2 ▶ croak 'spawn(): env must be a hash reference' if ref($env) ne 'HASH';
Branch: 1 branch
BranchTrueFalseTotal
if ref $env ne "HASH" 0 2 2
167 2 my %copy;
168 2 for my $name (keys %$env) {
169 2 ▶ croak 'spawn(): environment names must be nonempty and cannot contain = or NUL'
Branch: 1 branch
BranchTrueFalseTotal
if $name eq "" or $name =~ /[=\0]/u 0 2 2
Condition33%1/3
$name eq "" or $name =~ /[=\0]/u
l!l&&r!l&&!r
002
MC/DC0%0/2
$name eq "" or $name =~ /[=\0]/u
$name eq "" $name =~ /[=\0]/u
Truth table33%1/3
A or B
A= $name eq ""B= $name =~ /[=\0]/u
ABresult
1X1
011
000
170 if $name eq '' || $name =~ /[=\0]/;
171 2 my $value = $env->{$name};
172 2 ▶ croak 'spawn(): environment values must be defined scalars without NUL'
Branch: 1 branch
BranchTrueFalseTotal
if not defined $value or ref $value or "$value" =~ /\0/u 0 2 2
Condition33%2/6
not defined $value or ref $value or "$value" =~ /\0/u
l!l&&r!l&&!r
002
not defined $value or ref $value
l!l&&r!l&&!r
002
MC/DC0%0/3
not defined $value or ref $value or "$value" =~ /\0/u
not defined $value ref $value "$value" =~ /\0/u
Truth table25%1/4
not(A) or B or C
A= not defined $valueB= ref $valueC= "$value" =~ /\0/u
ABCresult
1XX1
01X1
0011
0000
173 if !defined($value) || ref($value) || "$value" =~ /\0/;
174 2 my ($byte_name, $byte_value) = ("$name", "$value");
175 2 ▶ croak 'spawn(): environment names and values must be byte strings'
Branch: 1 branch
BranchTrueFalseTotal
unless utf8::downgrade($byte_name, 1) and utf8::downgrade($byte_value, 1) 0 2 2
Condition33%1/3
utf8::downgrade($byte_name, 1) and utf8::downgrade($byte_value, 1)
!ll&&!rl&&r
002
MC/DC0%0/2
utf8::downgrade($byte_name, 1) and utf8::downgrade($byte_value, 1)
utf8::downgrade($byte_name, 1) utf8::downgrade($byte_value, 1)
Truth table33%1/3
A and B
A= utf8::downgrade($byte_name, 1)B= utf8::downgrade($byte_value, 1)
ABresult
0X0
100
111
176 if !utf8::downgrade($byte_name, 1)
177 || !utf8::downgrade($byte_value, 1);
178 2 $copy{$byte_name} = $byte_value;
179 }
180 2 $env = \%copy;
181 }
182  
183 33 my %stdio;
184 33 for my $name (qw(stdin stdout stderr)) {
185 $stdio{$name} = exists($option{$name})
186 98 ▶ ? delete($option{$name}) : 'inherit';
Branch: 1 branch
BranchTrueFalseTotal
exists $option{$name} ? : 63 35 98
187 98 _validate_stdio($name, $stdio{$name});
188 }
189 32 my %configured = %{ $descriptor->{options} };
190 32 for my $name (keys %configured) {
191 160 ▶ next if !exists $option{$name};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $option{$name} 152 8 160
192 8 $configured{$name} = delete $option{$name};
193 }
194 $configured{read_size} = _integer(
195 32 'spawn():', 'read_size', $configured{read_size}, 1,
196 );
197 $configured{max_reads_per_tick} = _integer(
198 32 'spawn():', 'max_reads_per_tick', $configured{max_reads_per_tick}, 1,
199 );
200 32 for my $name (qw(stdin_high_watermark stdin_low_watermark
201 max_pending_stdin)) {
202 $configured{$name} = _integer(
203 96 'spawn():', $name, $configured{$name}, 0,
204 );
205 }
206 croak 'spawn(): stdin_low_watermark must be <= stdin_high_watermark'
207 if $configured{stdin_low_watermark}
208 32 ▶ > $configured{stdin_high_watermark};
Branch: 1 branch
BranchTrueFalseTotal
if $configured{"stdin_low_watermark"} > $configured{"stdin_high_watermark"} 0 32 32
209 32 ▶ croak 'spawn(): unknown options: ' . join(', ', sort keys %option)
Branch: 1 branch
BranchTrueFalseTotal
if %option 0 32 32
210 if %option;
211 32 $descriptor = { %$descriptor, options => \%configured };
212  
213 32 my $callback = $descriptor->{callbacks};
214 croak 'spawn(): on_stdout requires stdout => pipe'
215 32 ▶ if $callback->{on_stdout} && $stdio{stdout} ne 'pipe';
Branch: 1 branch
BranchTrueFalseTotal
if $callback->{"on_stdout"} and $stdio{"stdout"} ne "pipe" 1 31 32
Condition100%3/3
$callback->{"on_stdout"} and $stdio{"stdout"} ne "pipe"
!ll&&!rl&&r
2381
MC/DC100%2/2
$callback->{"on_stdout"} and $stdio{"stdout"} ne "pipe"
$callback->{"on_stdout"} $stdio{"stdout"} ne "pipe"
Truth table100%3/3
A and B
A= $callback->{"on_stdout"}B= $stdio{"stdout"} ne "pipe"
ABresult
0X0
100
111
216 croak 'spawn(): on_stdout_eof requires stdout => pipe'
217 31 ▶ if $callback->{on_stdout_eof} && $stdio{stdout} ne 'pipe';
Branch: 1 branch
BranchTrueFalseTotal
if $callback->{"on_stdout_eof"} and $stdio{"stdout"} ne "pipe" 0 31 31
Condition66%2/3
$callback->{"on_stdout_eof"} and $stdio{"stdout"} ne "pipe"
!ll&&!rl&&r
2650
MC/DC0%0/2
$callback->{"on_stdout_eof"} and $stdio{"stdout"} ne "pipe"
$callback->{"on_stdout_eof"} $stdio{"stdout"} ne "pipe"
Truth table66%2/3
A and B
A= $callback->{"on_stdout_eof"}B= $stdio{"stdout"} ne "pipe"
ABresult
0X0
100
111
218 croak 'spawn(): on_stderr requires stderr => pipe'
219 31 ▶ if $callback->{on_stderr} && $stdio{stderr} ne 'pipe';
Branch: 1 branch
BranchTrueFalseTotal
if $callback->{"on_stderr"} and $stdio{"stderr"} ne "pipe" 0 31 31
Condition66%2/3
$callback->{"on_stderr"} and $stdio{"stderr"} ne "pipe"
!ll&&!rl&&r
2650
MC/DC0%0/2
$callback->{"on_stderr"} and $stdio{"stderr"} ne "pipe"
$callback->{"on_stderr"} $stdio{"stderr"} ne "pipe"
Truth table66%2/3
A and B
A= $callback->{"on_stderr"}B= $stdio{"stderr"} ne "pipe"
ABresult
0X0
100
111
220 croak 'spawn(): on_stderr_eof requires stderr => pipe'
221 31 ▶ if $callback->{on_stderr_eof} && $stdio{stderr} ne 'pipe';
Branch: 1 branch
BranchTrueFalseTotal
if $callback->{"on_stderr_eof"} and $stdio{"stderr"} ne "pipe" 0 31 31
Condition66%2/3
$callback->{"on_stderr_eof"} and $stdio{"stderr"} ne "pipe"
!ll&&!rl&&r
2650
MC/DC0%0/2
$callback->{"on_stderr_eof"} and $stdio{"stderr"} ne "pipe"
$callback->{"on_stderr_eof"} $stdio{"stderr"} ne "pipe"
Truth table66%2/3
A and B
A= $callback->{"on_stderr_eof"}B= $stdio{"stderr"} ne "pipe"
ABresult
0X0
100
111
222 croak 'spawn(): on_stdin_drain requires stdin => pipe'
223 31 ▶ if $callback->{on_stdin_drain} && $stdio{stdin} ne 'pipe';
Branch: 1 branch
BranchTrueFalseTotal
if $callback->{"on_stdin_drain"} and $stdio{"stdin"} ne "pipe" 0 31 31
Condition33%1/3
$callback->{"on_stdin_drain"} and $stdio{"stdin"} ne "pipe"
!ll&&!rl&&r
3100
MC/DC0%0/2
$callback->{"on_stdin_drain"} and $stdio{"stdin"} ne "pipe"
$callback->{"on_stdin_drain"} $stdio{"stdin"} ne "pipe"
Truth table33%1/3
A and B
A= $callback->{"on_stdin_drain"}B= $stdio{"stdin"} ne "pipe"
ABresult
0X0
100
111
224  
225 31 return $class->_new_object(
226 descriptor => $descriptor, loop => $loop, data => $data,
227 mode => 'spawn', command => \@command, cwd => $cwd, env => $env,
228 stdio => \%stdio, reap => 1,
229 );
230 }
231  
232 98 ▶sub _validate_stdio ($name, $value) {
Subroutine _validate_stdio: called CC=10 SCAR=23.6
233 98 ▶ return if ref($value) && defined(fileno($value));
Branch: 1 branch
BranchTrueFalseTotal
if ref $value and defined fileno $value 3 95 98
Condition66%2/3
ref $value and defined fileno $value
!ll&&!rl&&r
9503
MC/DC50%1/2
ref $value and defined fileno $value
ref $value defined fileno $value
Truth table66%2/3
A and B
A= ref $valueB= defined fileno $value
ABresult
0X0
100
111
234 95 ▶ croak "spawn(): $name must be inherit, pipe, null, or a filehandle"
Branch: 1 branch
BranchTrueFalseTotal
if not defined $value or ref $value or $value ne "inherit" and $value ne "pipe" and $value ne "null" and not $name eq "stderr" && $value eq "stdout" 1 94 95
Condition77%14/18
not defined $value or ref $value or $value ne "inherit" and $value ne "pipe" and $value ne "null" and not $name eq "stderr" && $value eq "stdout"
l!l&&r!l&&!r
0194
not defined $value or ref $value
l!l&&r!l&&!r
0095
$value ne "inherit" and $value ne "pipe" and $value ne "null" and not $name eq "stderr" && $value eq "stdout"
!ll&&!rl&&r
9311
$value ne "inherit" and $value ne "pipe" and $value ne "null"
!ll&&!rl&&r
53402
$value ne "inherit" and $value ne "pipe"
!ll&&!rl&&r
351842
$name eq 'stderr' && $value eq 'stdout'
!ll&&!rl&&r
101
MC/DC57%4/7
not defined $value or ref $value or $value ne "inherit" and $value ne "pipe" and $value ne "null" and not $name eq "stderr" && $value eq "stdout"
not defined $value ref $value $value ne "inherit" $value ne "pipe" $value ne "null" $name eq 'stderr' $value eq 'stdout'
Truth table62%5/8
not(A) or B or C and D and E and not(F && G)
A= not defined $valueB= ref $valueC= $value ne "inherit"D= $value ne "pipe"E= $value ne "null"F= $name eq 'stderr'G= $value eq 'stdout'
ABCDEFGresult
1XXXXXX1
01XXXXX1
001110X1
00111101
000XXXX0
0010XXX0
00110XX0
00111110
235 if !defined($value) || ref($value)
236 || ($value ne 'inherit' && $value ne 'pipe' && $value ne 'null'
237 && !($name eq 'stderr' && $value eq 'stdout'));
238 94 return;
239 }
240  
241 32 ▶sub _new_object ($class, %argument) {
Subroutine _new_object: called CC=2 SCAR=6.9
242 32 my $loop = delete $argument{loop};
243 32 my $self = bless {
244 %argument,
245 loop => undef,
246 state => 'unattached',
247 pidfd => undef,
248 pid_watcher => undef,
249 stdin_fh => undef,
250 stdout_fh => undef,
251 stderr_fh => undef,
252 stdin_watcher => undef,
253 stdout_watcher => undef,
254 stderr_watcher => undef,
255 stdin_queue => [],
256 pending_stdin_bytes => 0,
257 stdin_above_high => 0,
258 stdin_closing => 0,
259 stdin_closed => 0,
260 stdout_closed => 1,
261 stderr_closed => 1,
262 exit_observed => 0,
263 exit_code => undef,
264 term_signal => undef,
265 core_dumped => 0,
266 raw_status => undef,
267 last_error => undef,
268 }, $class;
269 32 ▶ $loop->add($self) if defined $loop;
Branch: 1 branch
BranchTrueFalseTotal
if defined $loop 3 29 32
270 32 return $self;
271 }
272  
273 76 ▶sub _set_cloexec ($fh) {
Subroutine _set_cloexec: called CC=3 SCAR=11.4
274 76 my $flags = fcntl($fh, F_GETFD, 0);
275 76 ▶ die "fcntl(F_GETFD): $!" if !defined $flags;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $flags 0 76 76
276 76 ▶ fcntl($fh, F_SETFD, $flags | FD_CLOEXEC)
Branch: 1 branch
BranchTrueFalseTotal
fcntl $fh, 2, $flags | 1 or die "fcntl(F_SETFD): $!" 76 0 76
277 or die "fcntl(F_SETFD): $!";
278 76 return;
279 }
280  
281 18 ▶sub _set_nonblocking ($fh) {
Subroutine _set_nonblocking: called CC=3 SCAR=11.4
282 18 my $flags = fcntl($fh, F_GETFL, 0);
283 18 ▶ die "fcntl(F_GETFL): $!" if !defined $flags;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $flags 0 18 18
284 18 ▶ fcntl($fh, F_SETFL, $flags | O_NONBLOCK)
Branch: 1 branch
BranchTrueFalseTotal
fcntl $fh, 4, $flags | 2048 or die "fcntl(F_SETFL): $!" 18 0 18
285 or die "fcntl(F_SETFL): $!";
286 18 return;
287 }
288  
289 18 ▶sub _pipe_for ($direction) {
Subroutine _pipe_for: called CC=4 SCAR=16.9
290 18 my ($read_fd, $write_fd) = @{ _pipe_cloexec() };
291 18 my ($read, $write);
292 18 ▶ if (!open($read, '<&=', $read_fd)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (open $read, "<&=", $read_fd) 0 18 18
293 0 my $failure = "$!";
294 0 eval { _close_fd($read_fd) };
295 0 eval { _close_fd($write_fd) };
296 0 die "open pipe read handle: $failure";
297 }
298 18 ▶ if (!open($write, '>&=', $write_fd)) {
Branch: 1 branch
BranchTrueFalseTotal
unless (open $write, ">&=", $write_fd) 0 18 18
299 0 my $failure = "$!";
300 0 close $read;
301 0 eval { _close_fd($write_fd) };
302 0 die "open pipe write handle: $failure";
303 }
304 18 _set_cloexec($read);
305 18 _set_cloexec($write);
306 18 ▶ if ($direction eq 'stdin') {
Branch: 1 branch
BranchTrueFalseTotal
if ($direction eq "stdin") 5 13 18
307 5 _set_nonblocking($write);
308 5 return ($write, $read, [$read, $write]);
309 }
310 13 _set_nonblocking($read);
311 13 return ($read, $write, [$read, $write]);
312 }
313  
314 1 ▶sub _attachment_error ($failure, $default_operation) {
Subroutine _attachment_error: called CC=5 SCAR=17.5
315 1 ▶ return $failure if blessed($failure)
Branch: 1 branch
BranchTrueFalseTotal
if builtin::blessed($failure) and $failure->isa("Linux::Event::Error") 0 1 1
Condition33%1/3
builtin::blessed($failure) and $failure->isa("Linux::Event::Error")
!ll&&!rl&&r
100
MC/DC0%0/2
builtin::blessed($failure) and $failure->isa("Linux::Event::Error")
builtin::blessed($failure) $failure->isa("Linux::Event::Error")
Truth table33%1/3
A and B
A= builtin::blessed($failure)B= $failure->isa("Linux::Event::Error")
ABresult
0X0
100
111
316 && $failure->isa('Linux::Event::Error');
317 1 my $message = "$failure";
318 1 $message =~ s/\s+\z//;
319 1 my $operation = $default_operation;
320 1 ▶ if ($message =~ s/\A([A-Za-z][A-Za-z0-9_]*)(?:\([^)]*\))?:\s*//) {
Branch: 1 branch
BranchTrueFalseTotal
if ($message =~ s/\A([A-Za-z][A-Za-z0-9_]*)(?:\([^)]*\))?:\s*//u) 1 0 1
321 1 $operation = $1;
322 }
323 1 ▶ return Linux::Event::Error->new(
Condition50%1/2
$message || 'process setup failed'
l!l
10
MC/DC0%0/1
$message || 'process setup failed'
$message
Truth table50%1/2
A
A= $message
Aresult
11
00
324 type => 'process', operation => $operation,
325 message => $message || 'process setup failed',
326 );
327 }
328  
329 90 ▶sub _stdio_source ($self, $name, $owned, $close_fds) {
Subroutine _stdio_source: called CC=9 SCAR=22.0
330 90 my $mode = $self->{stdio}{$name};
331 90 ▶ return -1 if $mode eq 'inherit';
Branch: 1 branch
BranchTrueFalseTotal
if $mode eq "inherit" 28 62 90
332 62 ▶ return -2 if $name eq 'stderr' && $mode eq 'stdout';
Branch: 1 branch
BranchTrueFalseTotal
if $name eq "stderr" and $mode eq "stdout" 1 61 62
Condition100%3/3
$name eq "stderr" and $mode eq "stdout"
!ll&&!rl&&r
41201
MC/DC100%2/2
$name eq "stderr" and $mode eq "stdout"
$name eq "stderr" $mode eq "stdout"
Truth table100%3/3
A and B
A= $name eq "stderr"B= $mode eq "stdout"
ABresult
0X0
100
111
333 61 ▶ if ($mode eq 'pipe') {
Branch: 1 branch
BranchTrueFalseTotal
if ($mode eq "pipe") 18 43 61
334 18 my ($parent, $child, $all) = _pipe_for($name);
335 18 $self->{"${name}_fh"} = $parent;
336 18 ▶ $self->{"${name}_closed"} = 0 if $name ne 'stdin';
Branch: 1 branch
BranchTrueFalseTotal
if $name ne "stdin" 13 5 18
337 18 push @$owned, $child;
338 18 push @$close_fds, map { fileno($_) } @$all;
339 18 return fileno($child);
340 }
341 43 ▶ if ($mode eq 'null') {
Branch: 1 branch
BranchTrueFalseTotal
if ($mode eq "null") 40 3 43
342 40 ▶ my $operator = $name eq 'stdin' ? '<' : '>';
Branch: 1 branch
BranchTrueFalseTotal
$name eq 'stdin' ? : 13 27 40
343 40 ▶ open(my $null, $operator, '/dev/null') or die "open /dev/null: $!";
Branch: 1 branch
BranchTrueFalseTotal
open my $null, $operator, "/dev/null" or die "open /dev/null: $!" 40 0 40
344 40 _set_cloexec($null);
345 40 push @$owned, $null;
346 40 push @$close_fds, fileno($null);
347 40 return fileno($null);
348 }
349 3 my $fd = fileno($mode);
350 3 push @$close_fds, $fd;
351 3 return $fd;
352 }
353  
354 31 ▶sub _attach_to_loop ($self, $loop) {
Subroutine _attach_to_loop: called CC=17 SCAR=38.7
355 croak 'add(): Process is not unattached'
356 31 ▶ if $self->{state} ne 'unattached' || $self->{loop};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"state"} ne "unattached" or $self->{"loop"} 0 31 31
Condition33%1/3
$self->{"state"} ne "unattached" or $self->{"loop"}
l!l&&r!l&&!r
0031
MC/DC0%0/2
$self->{"state"} ne "unattached" or $self->{"loop"}
$self->{"state"} ne "unattached" $self->{"loop"}
Truth table33%1/3
A or B
A= $self->{"state"} ne "unattached"B= $self->{"loop"}
ABresult
1X1
011
000
357 31 $self->{loop} = $loop;
358 31 ▶ if ($self->{mode} eq 'observe') {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{'mode'} eq 'observe') { } 1 30 31
359 1 my $pidfd = eval { _pidfd_open($self->{pid}) };
360 1 ▶ if (!defined $pidfd) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $pidfd) 0 1 1
361 0 my $failure = _attachment_error($@, 'pidfd_open');
362 0 $self->{loop} = undef;
363 0 die $failure;
364 }
365 1 $self->{pidfd} = $pidfd;
366 } else {
367 30 my (@owned, @close_fds);
368 30 my ($stdin_fd, $stdout_fd, $stderr_fd);
369 30 my $ok = eval {
370 30 $stdin_fd = $self->_stdio_source('stdin', \@owned, \@close_fds);
371 30 $stdout_fd = $self->_stdio_source('stdout', \@owned, \@close_fds);
372 30 $stderr_fd = $self->_stdio_source('stderr', \@owned, \@close_fds);
373 my $result = _spawn(
374 $self->{command}, $self->{env}, $self->{cwd},
375 30 $stdin_fd, $stdout_fd, $stderr_fd, \@close_fds,
376 );
377 29 ($self->{pid}, $self->{pidfd}) = @$result;
378 29 1;
379 };
380 30 my $failure = $@;
381 30 close $_ for @owned;
382 30 ▶ if (!$ok) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($ok) 1 29 30
383 1 ▶ close(delete $self->{stdin_fh}) if $self->{stdin_fh};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"stdin_fh"} 0 1 1
384 1 ▶ close(delete $self->{stdout_fh}) if $self->{stdout_fh};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"stdout_fh"} 0 1 1
385 1 ▶ close(delete $self->{stderr_fh}) if $self->{stderr_fh};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"stderr_fh"} 0 1 1
386 1 $self->{loop} = undef;
387 1 die _attachment_error($failure, 'spawn');
388 }
389 }
390 30 $self->{state} = 'running';
391 30 my $registered = eval { $self->_register_watchers; 1 };
392 30 ▶ if (!$registered) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($registered) 0 30 30
393 0 ▶ my $failure = $@ || 'could not register Process descriptors';
Condition0%0/2
$@ || 'could not register Process descriptors'
l!l
00
MC/DC0%0/1
$@ || 'could not register Process descriptors'
$@
Truth table0%0/2
A
A= $@
Aresult
11
00
394 0 ▶ if ($self->{mode} eq 'spawn' && defined $self->{pid}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"mode"} eq "spawn" and defined $self->{"pid"}) 0 0 0
Condition0%0/3
$self->{"mode"} eq "spawn" and defined $self->{"pid"}
!ll&&!rl&&r
000
MC/DC0%0/2
$self->{"mode"} eq "spawn" and defined $self->{"pid"}
$self->{"mode"} eq "spawn" defined $self->{"pid"}
Truth table0%0/3
A and B
A= $self->{"mode"} eq "spawn"B= defined $self->{"pid"}
ABresult
0X0
100
111
395 0 ▶ if (defined $self->{pidfd}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $self->{'pidfd'}) { } 0 0 0
396 0 eval { _pidfd_send($self->{pidfd}, SIGKILL); 1 };
397 } else {
398 0 kill SIGKILL, $self->{pid};
399 }
400 0 ▶ while (waitpid($self->{pid}, 0) < 0 && $! == Errno::EINTR()) { }
Branch: 1 branch
BranchTrueFalseTotal
if (waitpid($self->{"pid"}, 0) < 0 and $! == 4) 0 0 0
Condition0%0/3
waitpid($self->{"pid"}, 0) < 0 and $! == 4
!ll&&!rl&&r
000
MC/DC0%0/2
waitpid($self->{"pid"}, 0) < 0 and $! == 4
waitpid($self->{"pid"}, 0) < 0 $! == 4
Truth table0%0/3
A and B
A= waitpid($self->{"pid"}, 0) < 0B= $! == 4
ABresult
0X0
100
111
401 }
402 0 $self->{state} = 'failed';
403 0 $self->_release_handles;
404 0 $self->{loop} = undef;
405 0 die _attachment_error($failure, 'watch');
406 }
407 30 return $self;
408 }
409  
410 30 ▶sub _register_watchers ($self) {
Subroutine _register_watchers: called CC=6 SCAR=18.0
411 30 my $loop = $self->{loop};
412 $self->{pid_watcher} = $loop->watch(
413 30 fd => $self->{pidfd}, _internal => 1, data => $self,
414 read => \&_pid_ready, error => \&_pid_ready,
415 _callback_data_arg => 1,
416 );
417 30 ▶ if ($self->{stdout_fh}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"stdout_fh"}) 8 22 30
418 $self->{stdout_watcher} = $loop->watch(
419 8 fh => $self->{stdout_fh}, _internal => 1, data => $self,
420 read => \&_stdout_ready, error => \&_stdout_ready,
421 _callback_data_arg => 1,
422 );
423 }
424 30 ▶ if ($self->{stderr_fh}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"stderr_fh"}) 5 25 30
425 $self->{stderr_watcher} = $loop->watch(
426 5 fh => $self->{stderr_fh}, _internal => 1, data => $self,
427 read => \&_stderr_ready, error => \&_stderr_ready,
428 _callback_data_arg => 1,
429 );
430 }
431 30 ▶ if ($self->{stdin_fh}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"stdin_fh"}) 5 25 30
432 5 ▶ if ($self->{stdin_closed}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{'stdin_closed'}) { } 0 5 5
433 0 close delete $self->{stdin_fh};
434 } else {
435 $self->{stdin_watcher} = $loop->watch(
436 5 fh => $self->{stdin_fh}, _internal => 1, data => $self,
437 write => \&_stdin_ready, error => \&_stdin_error,
438 _callback_data_arg => 1,
439 );
440 $self->{stdin_watcher}->disable_write
441 5 ▶ if !@{ $self->{stdin_queue} };
Branch: 1 branch
BranchTrueFalseTotal
unless @{$self->{"stdin_queue"};} 3 2 5
442 5 $self->_flush_stdin;
443 }
444 }
445 30 return;
446 }
447  
448 22 ▶sub _stdout_ready ($self) { $self->_read_output('stdout', 0) }
Subroutine _stdout_ready: called CC=1 SCAR=0.0
449 18 ▶sub _stderr_ready ($self) { $self->_read_output('stderr', 0) }
Subroutine _stderr_ready: called CC=1 SCAR=0.0
450  
451 41 ▶sub _read_output ($self, $name, $unbounded) {
Subroutine _read_output: called CC=15 SCAR=29.0
452 41 ▶ my $fh = $self->{"${name}_fh"} or return;
Branch: 1 branch
BranchTrueFalseTotal
my $fh = $$self{"${name}_fh"} or return 41 0 41
453 41 ▶ my $maximum = $unbounded ? 0 : $self->{descriptor}{options}{max_reads_per_tick};
Branch: 1 branch
BranchTrueFalseTotal
$unbounded ? : 1 40 41
454 41 ▶ if ($_PIPE_DRAIN_ENGINE eq 'native') {
Branch: 1 branch
BranchTrueFalseTotal
if ($Linux::Event::Kernel::Process::_PIPE_DRAIN_ENGINE eq "native") 25 16 41
455 25 my $callback = $self->{descriptor}{callbacks}{"on_$name"};
456 my ($status, $errno) = _drain_pipe(
457 $self, $callback, fileno($fh),
458 25 $self->{descriptor}{options}{read_size}, $maximum,
459 );
460 24 ▶ if ($status == 1) {
Branch: 2 branches
BranchTrueFalseTotal
if ($status == 1) { } 8 16 24
elsif ($status == 2) { } 0 16 16
461 8 $self->_close_output($name, 1);
462 } elsif ($status == 2) {
463 0 $self->_close_output($name, 1);
464 0 $self->_report(Linux::Event::Error->new(
465 type => 'process_io', operation => "read_$name",
466 errno => $errno, message => _message($errno),
467 ));
468 }
469 24 return;
470 }
471 16 my $reads = 0;
472 16 ▶ while (!$maximum || $reads++ < $maximum) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $maximum or $reads++ < $maximum) 90 10 100
Condition66%2/3
not $maximum or $reads++ < $maximum
l!l&&r!l&&!r
09010
MC/DC50%1/2
not $maximum or $reads++ < $maximum
not $maximum $reads++ < $maximum
Truth table66%2/3
not(A) or B
A= not $maximumB= $reads++ < $maximum
ABresult
1X1
011
000
473 my $count = sysread(
474 $fh, my $bytes, $self->{descriptor}{options}{read_size},
475 90 );
476 90 ▶ if (defined($count) && $count > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $count and $count > 0) 84 6 90
Condition100%3/3
defined $count and $count > 0
!ll&&!rl&&r
2484
MC/DC100%2/2
defined $count and $count > 0
defined $count $count > 0
Truth table100%3/3
A and B
A= defined $countB= $count > 0
ABresult
0X0
100
111
477 84 my $callback = $self->{descriptor}{callbacks}{"on_$name"};
478 84 ▶ $callback->($self, $bytes) if $callback;
Branch: 1 branch
BranchTrueFalseTotal
if $callback 84 0 84
479 84 next;
480 }
481 6 ▶ if (defined($count) && $count == 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $count and $count == 0) 4 2 6
Condition66%2/3
defined $count and $count == 0
!ll&&!rl&&r
204
MC/DC50%1/2
defined $count and $count == 0
defined $count $count == 0
Truth table66%2/3
A and B
A= defined $countB= $count == 0
ABresult
0X0
100
111
482 4 $self->_close_output($name, 1);
483 4 last;
484 }
485 2 ▶ last if $! == Errno::EAGAIN() || $! == Errno::EWOULDBLOCK();
Branch: 1 branch
BranchTrueFalseTotal
if $! == 11 or $! == 11 2 0 2
Condition33%1/3
$! == 11 or $! == 11
l!l&&r!l&&!r
200
MC/DC0%0/2
$! == 11 or $! == 11
$! == 11 $! == 11
Truth table33%1/3
A or B
A= $! == 11B= $! == 11
ABresult
1X1
011
000
486 0 my $errno = 0 + $!;
487 0 $self->_close_output($name, 1);
488 0 $self->_report(Linux::Event::Error->new(
489 type => 'process_io', operation => "read_$name", errno => $errno,
490 message => _message($errno),
491 ));
492 0 last;
493 }
494 16 return;
495 }
496  
497 13 ▶sub _close_output ($self, $name, $fire_eof) {
Subroutine _close_output: called CC=6 SCAR=18.2
498 13 ▶ if (my $watcher = delete $self->{"${name}_watcher"}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $watcher = delete $$self{"${name}_watcher"}) 13 0 13
499 13 $watcher->cancel;
500 }
501 13 ▶ if (my $fh = delete $self->{"${name}_fh"}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $fh = delete $$self{"${name}_fh"}) 13 0 13
502 13 close $fh;
503 }
504 13 ▶ return if $self->{"${name}_closed"}++;
Branch: 1 branch
BranchTrueFalseTotal
if $$self{"${name}_closed"}++ 0 13 13
505 13 my $callback = $self->{descriptor}{callbacks}{"on_${name}_eof"};
506 13 ▶ $callback->($self) if $fire_eof && $callback;
Branch: 1 branch
BranchTrueFalseTotal
if $fire_eof and $callback 10 3 13
Condition100%3/3
$fire_eof and $callback
!ll&&!rl&&r
1210
MC/DC100%2/2
$fire_eof and $callback
$fire_eof $callback
Truth table100%3/3
A and B
A= $fire_eofB= $callback
ABresult
0X0
100
111
507 13 return;
508 }
509  
510 6 ▶sub write_stdin ($self, $bytes) {
Subroutine write_stdin: called CC=15 SCAR=32.9
Pod documented
511 croak 'write_stdin(): stdin is not configured as a pipe'
512 6 ▶ if $self->{mode} ne 'spawn' || $self->{stdio}{stdin} ne 'pipe';
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"mode"} ne "spawn" or $self->{"stdio"}{"stdin"} ne "pipe" 0 6 6
Condition33%1/3
$self->{"mode"} ne "spawn" or $self->{"stdio"}{"stdin"} ne "pipe"
l!l&&r!l&&!r
006
MC/DC0%0/2
$self->{"mode"} ne "spawn" or $self->{"stdio"}{"stdin"} ne "pipe"
$self->{"mode"} ne "spawn" $self->{"stdio"}{"stdin"} ne "pipe"
Truth table33%1/3
A or B
A= $self->{"mode"} ne "spawn"B= $self->{"stdio"}{"stdin"} ne "pipe"
ABresult
1X1
011
000
513 croak 'write_stdin(): stdin is closing or closed'
514 6 ▶ if $self->{stdin_closing} || $self->{stdin_closed};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"stdin_closing"} or $self->{"stdin_closed"} 1 5 6
Condition66%2/3
$self->{"stdin_closing"} or $self->{"stdin_closed"}
l!l&&r!l&&!r
015
MC/DC50%1/2
$self->{"stdin_closing"} or $self->{"stdin_closed"}
$self->{"stdin_closing"} $self->{"stdin_closed"}
Truth table66%2/3
A or B
A= $self->{"stdin_closing"}B= $self->{"stdin_closed"}
ABresult
1X1
011
000
515 5 ▶ croak 'write_stdin(): bytes must be a defined scalar'
Branch: 1 branch
BranchTrueFalseTotal
if not defined $bytes or ref $bytes 0 5 5
Condition33%1/3
not defined $bytes or ref $bytes
l!l&&r!l&&!r
005
MC/DC0%0/2
not defined $bytes or ref $bytes
not defined $bytes ref $bytes
Truth table33%1/3
not(A) or B
A= not defined $bytesB= ref $bytes
ABresult
1X1
011
000
516 if !defined($bytes) || ref($bytes);
517 5 $bytes = "$bytes";
518 5 ▶ croak 'write_stdin(): bytes must be a byte string'
Branch: 1 branch
BranchTrueFalseTotal
unless utf8::downgrade($bytes, 1) 0 5 5
519 if !utf8::downgrade($bytes, 1);
520 5 ▶ return 1 if $bytes eq '';
Branch: 1 branch
BranchTrueFalseTotal
if $bytes eq "" 0 5 5
521 5 ▶ if ($self->{stdin_fh} && !@{ $self->{stdin_queue} }) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"stdin_fh"} and not @{$self->{"stdin_queue"};}) 3 2 5
Condition66%2/3
$self->{"stdin_fh"} and not @{$self->{"stdin_queue"};}
!ll&&!rl&&r
203
MC/DC50%1/2
$self->{"stdin_fh"} and not @{$self->{"stdin_queue"};}
$self->{"stdin_fh"} not @{$self->{"stdin_queue"};}
Truth table66%2/3
A and not(B)
A= $self->{"stdin_fh"}B= not @{$self->{"stdin_queue"};}
ABresult
0X0
100
111
522 3 my ($written, $errno) = _write_pipe(fileno($self->{stdin_fh}), $bytes);
523 3 ▶ return 1 if $written == length($bytes);
Branch: 1 branch
BranchTrueFalseTotal
if $written == length $bytes 2 1 3
524 1 ▶ if ($written > 0) {
Branch: 2 branches
BranchTrueFalseTotal
if ($written > 0) { } 1 0 1
elsif ($errno != 11 and $errno != 11) { } 0 0 0
525 1 $bytes = substr($bytes, $written);
526 ▶ } elsif ($errno != Errno::EAGAIN() && $errno != Errno::EWOULDBLOCK()) {
Condition0%0/3
$errno != 11 and $errno != 11
!ll&&!rl&&r
000
MC/DC0%0/2
$errno != 11 and $errno != 11
$errno != 11 $errno != 11
Truth table0%0/3
A and B
A= $errno != 11B= $errno != 11
ABresult
0X0
100
111
527 0 $self->_stdin_failure($errno);
528 0 return undef;
529 }
530 }
531 3 return $self->_queue_stdin($bytes);
532 }
533  
534 3 ▶sub _queue_stdin ($self, $bytes) {
Subroutine _queue_stdin: called CC=6 SCAR=18.0
535 3 my $pending = $self->{pending_stdin_bytes} + length($bytes);
536 3 my $limit = $self->{descriptor}{options}{max_pending_stdin};
537 3 ▶ if ($limit && $pending > $limit) {
Branch: 1 branch
BranchTrueFalseTotal
if ($limit and $pending > $limit) 1 2 3
Condition66%2/3
$limit and $pending > $limit
!ll&&!rl&&r
201
MC/DC50%1/2
$limit and $pending > $limit
$limit $pending > $limit
Truth table66%2/3
A and B
A= $limitB= $pending > $limit
ABresult
0X0
100
111
538 1 my $error = Linux::Event::Error->new(
539 type => 'output_limit', operation => 'write_stdin',
540 message => "pending stdin would exceed $limit bytes",
541 pending_bytes => $pending, limit => $limit,
542 );
543 1 $self->_close_stdin_handle;
544 1 $self->_report($error);
545 1 return undef;
546 }
547 2 push @{ $self->{stdin_queue} }, $bytes;
548 2 $self->{pending_stdin_bytes} = $pending;
549 $self->{stdin_above_high} = 1
550 2 ▶ if $pending > $self->{descriptor}{options}{stdin_high_watermark};
Branch: 1 branch
BranchTrueFalseTotal
if $pending > $self->{"descriptor"}{"options"}{"stdin_high_watermark"} 1 1 2
551 2 ▶ $self->{stdin_watcher}->enable_write if $self->{stdin_watcher};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"stdin_watcher"} 0 2 2
552 2 ▶ return $self->{stdin_above_high} ? 0 : 1;
Branch: 1 branch
BranchTrueFalseTotal
$self->{'stdin_above_high'} ? : 1 1 2
553 }
554  
555 0 ▶sub _stdin_ready ($self) { $self->_flush_stdin }
Subroutine _stdin_ready: not called CC=1 SCAR=6.9
556 1 ▶sub _stdin_error ($self) { $self->_stdin_failure(Errno::EPIPE()) }
Subroutine _stdin_error: called CC=1 SCAR=0.0
557  
558 5 ▶sub _flush_stdin ($self) {
Subroutine _flush_stdin: called CC=14 SCAR=29.0
559 5 ▶ my $fh = $self->{stdin_fh} or return;
Branch: 1 branch
BranchTrueFalseTotal
my $fh = $self->{"stdin_fh"} or return 5 0 5
560 5 ▶ while (defined(my $bytes = $self->{stdin_queue}[0])) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined(my $bytes = $self->{"stdin_queue"}[0])) 3 4 7
561 3 my ($written, $errno) = _write_pipe(fileno($fh), $bytes);
562 3 ▶ if ($written == length($bytes)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($written == length $bytes) 1 2 3
563 1 shift @{ $self->{stdin_queue} };
564 1 $self->{pending_stdin_bytes} -= length($bytes);
565 1 next;
566 }
567 2 ▶ if ($written > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($written > 0) 1 1 2
568 1 substr($self->{stdin_queue}[0], 0, $written, '');
569 1 $self->{pending_stdin_bytes} -= $written;
570 1 next;
571 }
572 1 ▶ last if $errno == Errno::EAGAIN() || $errno == Errno::EWOULDBLOCK();
Branch: 1 branch
BranchTrueFalseTotal
if $errno == 11 or $errno == 11 1 0 1
Condition33%1/3
$errno == 11 or $errno == 11
l!l&&r!l&&!r
100
MC/DC0%0/2
$errno == 11 or $errno == 11
$errno == 11 $errno == 11
Truth table33%1/3
A or B
A= $errno == 11B= $errno == 11
ABresult
1X1
011
000
573 0 $self->_stdin_failure($errno);
574 0 return;
575 }
576 $self->{stdin_watcher}->disable_write
577 5 ▶ if $self->{stdin_watcher} && !@{ $self->{stdin_queue} };
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"stdin_watcher"} and not @{$self->{"stdin_queue"};} 4 1 5
Condition66%2/3
$self->{"stdin_watcher"} and not @{$self->{"stdin_queue"};}
!ll&&!rl&&r
014
MC/DC50%1/2
$self->{"stdin_watcher"} and not @{$self->{"stdin_queue"};}
$self->{"stdin_watcher"} not @{$self->{"stdin_queue"};}
Truth table66%2/3
A and not(B)
A= $self->{"stdin_watcher"}B= not @{$self->{"stdin_queue"};}
ABresult
0X0
100
111
578 5 ▶ if ($self->{stdin_above_high}
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"stdin_above_high"} and $self->{"pending_stdin_bytes"} <= $self->{"descriptor"}{"options"}{"stdin_low_watermark"}) 0 5 5
Condition66%2/3
$self->{"stdin_above_high"} and $self->{"pending_stdin_bytes"} <= $self->{"descriptor"}{"options"}{"stdin_low_watermark"}
!ll&&!rl&&r
410
MC/DC0%0/2
$self->{"stdin_above_high"} and $self->{"pending_stdin_bytes"} <= $self->{"descriptor"}{"options"}{"stdin_low_watermark"}
$self->{"stdin_above_high"} $self->{"pending_stdin_bytes"} <= $self->{"descriptor"}{"options"}{"stdin_low_watermark"}
Truth table66%2/3
A and B
A= $self->{"stdin_above_high"}B= $self->{"pending_stdin_bytes"} <= $self->{"descriptor"}{"options"}{"stdin_low_watermark"}
ABresult
0X0
100
111
579 && $self->{pending_stdin_bytes}
580 <= $self->{descriptor}{options}{stdin_low_watermark}) {
581 0 $self->{stdin_above_high} = 0;
582 0 my $callback = $self->{descriptor}{callbacks}{on_stdin_drain};
583 0 ▶ $callback->($self) if $callback;
Branch: 1 branch
BranchTrueFalseTotal
if $callback 0 0 0
584 }
585 $self->_close_stdin_handle
586 5 ▶ if $self->{stdin_closing} && !@{ $self->{stdin_queue} };
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"stdin_closing"} and not @{$self->{"stdin_queue"};} 1 4 5
Condition66%2/3
$self->{"stdin_closing"} and not @{$self->{"stdin_queue"};}
!ll&&!rl&&r
401
MC/DC50%1/2
$self->{"stdin_closing"} and not @{$self->{"stdin_queue"};}
$self->{"stdin_closing"} not @{$self->{"stdin_queue"};}
Truth table66%2/3
A and not(B)
A= $self->{"stdin_closing"}B= not @{$self->{"stdin_queue"};}
ABresult
0X0
100
111
587 5 return;
588 }
589  
590 1 ▶sub _stdin_failure ($self, $errno) {
Subroutine _stdin_failure: called CC=1 SCAR=0.0
591 1 $self->_close_stdin_handle;
592 1 $self->_report(Linux::Event::Error->new(
593 type => 'process_io', operation => 'write_stdin', errno => $errno,
594 message => _message($errno),
595 ));
596 1 return;
597 }
598  
599 30 ▶sub _close_stdin_handle ($self) {
Subroutine _close_stdin_handle: called CC=3 SCAR=11.0
600 30 ▶ if (my $watcher = delete $self->{stdin_watcher}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $watcher = delete $self->{"stdin_watcher"}) 5 25 30
601 5 $watcher->cancel;
602 }
603 30 ▶ if (my $fh = delete $self->{stdin_fh}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $fh = delete $self->{"stdin_fh"}) 5 25 30
604 5 close $fh;
605 }
606 30 $self->{stdin_closed} = 1;
607 30 $self->{stdin_queue} = [];
608 30 $self->{pending_stdin_bytes} = 0;
609 30 return;
610 }
611  
612 3 ▶sub close_stdin ($self) {
Subroutine close_stdin: called CC=7 SCAR=21.8
Pod documented
613 croak 'close_stdin(): stdin is not configured as a pipe'
614 3 ▶ if $self->{mode} ne 'spawn' || $self->{stdio}{stdin} ne 'pipe';
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"mode"} ne "spawn" or $self->{"stdio"}{"stdin"} ne "pipe" 0 3 3
Condition33%1/3
$self->{"mode"} ne "spawn" or $self->{"stdio"}{"stdin"} ne "pipe"
l!l&&r!l&&!r
003
MC/DC0%0/2
$self->{"mode"} ne "spawn" or $self->{"stdio"}{"stdin"} ne "pipe"
$self->{"mode"} ne "spawn" $self->{"stdio"}{"stdin"} ne "pipe"
Truth table33%1/3
A or B
A= $self->{"mode"} ne "spawn"B= $self->{"stdio"}{"stdin"} ne "pipe"
ABresult
1X1
011
000
615 3 ▶ return $self if $self->{stdin_closing} || $self->{stdin_closed};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"stdin_closing"} or $self->{"stdin_closed"} 0 3 3
Condition33%1/3
$self->{"stdin_closing"} or $self->{"stdin_closed"}
l!l&&r!l&&!r
003
MC/DC0%0/2
$self->{"stdin_closing"} or $self->{"stdin_closed"}
$self->{"stdin_closing"} $self->{"stdin_closed"}
Truth table33%1/3
A or B
A= $self->{"stdin_closing"}B= $self->{"stdin_closed"}
ABresult
1X1
011
000
616 3 $self->{stdin_closing} = 1;
617 $self->_close_stdin_handle
618 3 ▶ if $self->{stdin_fh} && !@{ $self->{stdin_queue} };
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"stdin_fh"} and not @{$self->{"stdin_queue"};} 2 1 3
Condition66%2/3
$self->{"stdin_fh"} and not @{$self->{"stdin_queue"};}
!ll&&!rl&&r
102
MC/DC50%1/2
$self->{"stdin_fh"} and not @{$self->{"stdin_queue"};}
$self->{"stdin_fh"} not @{$self->{"stdin_queue"};}
Truth table66%2/3
A and not(B)
A= $self->{"stdin_fh"}B= not @{$self->{"stdin_queue"};}
ABresult
0X0
100
111
619 3 return $self;
620 }
621  
622 138 ▶sub _pid_ready ($self) {
Subroutine _pid_ready: called CC=22 SCAR=32.9
623 138 ▶ return if $self->{state} ne 'running';
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"state"} ne "running" 0 138 138
624 138 ▶ if ($self->{reap}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"reap"}) 138 0 138
625 138 my $status = eval { _pidfd_reap($self->{pidfd}) };
626 138 ▶ if ($@) {
Branch: 1 branch
BranchTrueFalseTotal
if ($@) 0 138 138
627 0 my $message = "$@";
628 0 $self->_runtime_fail(Linux::Event::Error->new(
629 type => 'process', operation => 'waitid',
630 message => $message,
631 ));
632 0 return;
633 }
634 138 ▶ return if !defined $status;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $status 108 30 138
635 30 my ($code, $value) = @$status;
636 30 ▶ if ($code == 1) {
Branch: 2 branches
BranchTrueFalseTotal
if ($code == 1) { } 27 3 30
elsif ($code == 2 or $code == 3) { } 3 0 3
637 27 $self->{exit_code} = $value;
638 27 $self->{raw_status} = $value << 8;
639 ▶ } elsif ($code == 2 || $code == 3) {
Condition33%1/3
$code == 2 or $code == 3
l!l&&r!l&&!r
300
MC/DC0%0/2
$code == 2 or $code == 3
$code == 2 $code == 3
Truth table33%1/3
A or B
A= $code == 2B= $code == 3
ABresult
1X1
011
000
640 3 $self->{term_signal} = $value;
641 3 ▶ $self->{core_dumped} = $code == 3 ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$code == 3 ? : 0 3 3
642 3 ▶ $self->{raw_status} = $value | ($code == 3 ? 0x80 : 0);
Branch: 1 branch
BranchTrueFalseTotal
$code == 3 ? : 0 3 3
643 }
644 }
645 30 $self->{exit_observed} = 1;
646 30 ▶ if (my $watcher = delete $self->{pid_watcher}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $watcher = delete $self->{"pid_watcher"}) 30 0 30
647 30 $watcher->cancel;
648 }
649 30 ▶ if (defined(my $pidfd = delete $self->{pidfd})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined(my $pidfd = delete $self->{"pidfd"})) 30 0 30
650 30 _close_fd($pidfd);
651 }
652 30 ▶ $self->_close_stdin_handle if !$self->{stdin_closed};
Branch: 1 branch
BranchTrueFalseTotal
unless $self->{"stdin_closed"} 25 5 30
653 30 my $failure;
654 30 for my $name (qw(stdout stderr)) {
655 60 my $drained = eval {
656 60 ▶ $self->_read_output($name, 1) if $self->{"${name}_fh"};
Branch: 1 branch
BranchTrueFalseTotal
if $$self{"${name}_fh"} 1 59 60
657 59 ▶ $self->_close_output($name, 1) if $self->{"${name}_fh"};
Branch: 1 branch
BranchTrueFalseTotal
if $$self{"${name}_fh"} 0 59 59
658 59 1;
659 };
660 60 ▶ $failure //= $@ if !$drained;
Branch: 1 branch
BranchTrueFalseTotal
unless $drained 1 59 60
Condition33%1/3
$failure //= $@
l!l&&r!l&&!r
010
MC/DC0%0/2
$failure //= $@
$failure $@
Truth table33%1/3
A //= B
A= $failureB= $@
ABresult
1X1
011
000
661 60 ▶ $self->_close_output($name, 0) if $self->{"${name}_fh"};
Branch: 1 branch
BranchTrueFalseTotal
if $$self{"${name}_fh"} 1 59 60
662 }
663 30 $self->{state} = 'exited';
664 30 my $callback = $self->{descriptor}{callbacks}{on_exit};
665 30 my $called = eval { $callback->($self); 1 };
666 30 ▶ $failure //= $@ if !$called;
Branch: 1 branch
BranchTrueFalseTotal
unless $called 1 29 30
Condition33%1/3
$failure //= $@
l!l&&r!l&&!r
010
MC/DC0%0/2
$failure //= $@
$failure $@
Truth table33%1/3
A //= B
A= $failureB= $@
ABresult
1X1
011
000
667 30 undef $callback;
668 30 $self->{descriptor} = undef;
669 30 $self->{loop} = undef;
670 30 ▶ die $failure if defined $failure;
Branch: 1 branch
BranchTrueFalseTotal
if defined $failure 2 28 30
671 28 return;
672 }
673  
674 1 ▶sub _message ($errno) { local $! = $errno; return "$!" }
Subroutine _message: called CC=1 SCAR=0.0
675  
676 2 ▶sub _report ($self, $error) {
Subroutine _report: called CC=2 SCAR=7.4
677 2 $self->{last_error} = $error;
678 2 ▶ if (my $callback = $self->{descriptor}{callbacks}{on_error}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $callback = $self->{'descriptor'}{'callbacks'}{'on_error'}) { } 2 0 2
679 2 $callback->($self, $error);
680 } else {
681 0 warn "$error\n";
682 }
683 2 return;
684 }
685  
686 0 ▶sub _runtime_fail ($self, $error) {
Subroutine _runtime_fail: not called CC=2 SCAR=17.9
687 0 $self->{state} = 'failed';
688 0 $self->_release_handles;
689 0 my $reported = eval { $self->_report($error); 1 };
690 0 my $failure = $@;
691 0 $self->{descriptor} = undef;
692 0 $self->{loop} = undef;
693 0 ▶ die $failure if !$reported;
Branch: 1 branch
BranchTrueFalseTotal
unless $reported 0 0 0
694 0 return;
695 }
696  
697 0 ▶sub _fork_preflight ($self, $mode, $loop) {
Subroutine _fork_preflight: not called CC=5 SCAR=34.0
698 0 ▶ croak "fork(): Process does not support '$mode'" if $mode ne 'drop';
Branch: 1 branch
BranchTrueFalseTotal
if $mode ne "drop" 0 0 0
699 croak 'fork(): Process is not active in this Loop'
700 if $self->{state} ne 'running' || !$self->{loop}
701 0 ▶ || Scalar::Util::refaddr($self->{loop}) != Scalar::Util::refaddr($loop);
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"state"} ne "running" or not $self->{"loop"} or builtin::refaddr($self->{"loop"}) != builtin::refaddr($loop) 0 0 0
Condition0%0/6
$self->{"state"} ne "running" or not $self->{"loop"} or builtin::refaddr($self->{"loop"}) != builtin::refaddr($loop)
l!l&&r!l&&!r
000
$self->{"state"} ne "running" or not $self->{"loop"}
l!l&&r!l&&!r
000
MC/DC0%0/3
$self->{"state"} ne "running" or not $self->{"loop"} or builtin::refaddr($self->{"loop"}) != builtin::refaddr($loop)
$self->{"state"} ne "running" not $self->{"loop"} builtin::refaddr($self->{"loop"}) != builtin::refaddr($loop)
Truth table0%0/4
A or not(B) or C
A= $self->{"state"} ne "running"B= not $self->{"loop"}C= builtin::refaddr($self->{"loop"}) != builtin::refaddr($loop)
ABCresult
1XX1
01X1
0011
0000
702 0 return 1;
703 }
704  
705 0 ▶sub _fork_child_drop ($self, $loop) {
Subroutine _fork_child_drop: not called CC=4 SCAR=30.0
706 0 delete @$self{qw(pid_watcher stdin_watcher stdout_watcher stderr_watcher)};
707 0 ▶ if (defined(my $pidfd = delete $self->{pidfd})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined(my $pidfd = delete $self->{"pidfd"})) 0 0 0
708 0 eval { _close_fd($pidfd) };
709 }
710 0 for my $name (qw(stdin stdout stderr)) {
711 0 my $key = $name . '_fh';
712 0 ▶ close delete $self->{$key} if $self->{$key};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{$key} 0 0 0
713 }
714 0 $self->{stdin_queue} = [];
715 0 $self->{pending_stdin_bytes} = 0;
716 0 $self->{stdin_above_high} = 0;
717 0 $self->{loop} = undef;
718 0 $self->{descriptor} = undef;
719 0 $self->{state} = 'not_inherited';
720 0 return;
721 }
722  
723 2 ▶sub _release_handles ($self) {
Subroutine _release_handles: called CC=6 SCAR=19.9
724 2 for my $name (qw(pid stdin stdout stderr)) {
725 8 ▶ if (my $watcher = delete $self->{"${name}_watcher"}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $watcher = delete $$self{"${name}_watcher"}) 0 8 8
726 0 $watcher->cancel;
727 }
728 }
729 2 ▶ if (defined(my $pidfd = delete $self->{pidfd})) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined(my $pidfd = delete $self->{"pidfd"})) 0 2 2
730 0 eval { _close_fd($pidfd) };
731 }
732 2 for my $name (qw(stdin stdout stderr)) {
733 6 ▶ close delete $self->{"${name}_fh"} if $self->{"${name}_fh"};
Branch: 1 branch
BranchTrueFalseTotal
if $$self{"${name}_fh"} 0 6 6
734 }
735 2 $self->{stdin_queue} = [];
736 2 $self->{pending_stdin_bytes} = 0;
737 2 $self->{stdin_above_high} = 0;
738 2 return;
739 }
740  
741 5 ▶sub signal ($self, $number) {
Subroutine signal: called CC=10 SCAR=26.2
Pod documented
742 croak 'signal(): Process is not running'
743 5 ▶ if $self->{state} ne 'running' || !defined($self->{pidfd});
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"state"} ne "running" or not defined $self->{"pidfd"} 0 5 5
Condition33%1/3
$self->{"state"} ne "running" or not defined $self->{"pidfd"}
l!l&&r!l&&!r
005
MC/DC0%0/2
$self->{"state"} ne "running" or not defined $self->{"pidfd"}
$self->{"state"} ne "running" not defined $self->{"pidfd"}
Truth table33%1/3
A or not(B)
A= $self->{"state"} ne "running"B= not defined $self->{"pidfd"}
ABresult
1X1
011
000
744 5 ▶ croak 'signal(): signal must be a positive integer'
Branch: 1 branch
BranchTrueFalseTotal
if not defined $number or ref $number or not $number =~ /\A\d+\z/u or $number == 0 0 5 5
Condition33%3/9
not defined $number or ref $number or not $number =~ /\A\d+\z/u or $number == 0
l!l&&r!l&&!r
005
not defined $number or ref $number or not $number =~ /\A\d+\z/u
l!l&&r!l&&!r
005
not defined $number or ref $number
l!l&&r!l&&!r
005
MC/DC0%0/4
not defined $number or ref $number or not $number =~ /\A\d+\z/u or $number == 0
not defined $number ref $number not $number =~ /\A\d+\z/u $number == 0
Truth table20%1/5
not(A) or B or not(C) or D
A= not defined $numberB= ref $numberC= not $number =~ /\A\d+\z/uD= $number == 0
ABCDresult
1XXX1
01XX1
001X1
00011
00000
745 if !defined($number) || ref($number) || $number !~ /\A\d+\z/
746 || $number == 0;
747 5 my $sent = eval {
748 5 ▶ croak 'signal(): signal must be a valid Linux signal number'
Branch: 1 branch
BranchTrueFalseTotal
if $number > 64 2 3 5
749 if $number > SIGRTMAX;
750 3 _pidfd_send($self->{pidfd}, 0 + $number);
751 3 1;
752 };
753 5 ▶ if (!$sent) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($sent) 2 3 5
754 2 my $message = "$@";
755 2 $message =~ s/\s+\z//;
756 2 ▶ die Linux::Event::Error->new(
Condition50%1/2
$message || 'pidfd signal failed'
l!l
20
MC/DC0%0/1
$message || 'pidfd signal failed'
$message
Truth table50%1/2
A
A= $message
Aresult
11
00
757 type => 'process',
758 operation => 'signal',
759 message => $message || 'pidfd signal failed',
760 );
761 }
762 3 return $self;
763 }
764  
765 6 ▶sub pid ($self) { $self->{pid} }
Subroutine pid: called CC=1 SCAR=0.0
Pod documented
766 46 ▶sub loop ($self) { $self->{loop} }
Subroutine loop: called CC=1 SCAR=0.0
Pod undocumented
767 4 ▶sub state ($self) { $self->{state} }
Subroutine state: called CC=1 SCAR=0.0
Pod documented
768 0 ▶sub last_error ($self) { $self->{last_error} }
Subroutine last_error: not called CC=1 SCAR=6.9
Pod documented
769 1 ▶sub raw_status ($self) { $self->{raw_status} }
Subroutine raw_status: called CC=1 SCAR=0.0
Pod documented
770 36 ▶sub exit_code ($self) { $self->{exit_code} }
Subroutine exit_code: called CC=1 SCAR=0.0
Pod documented
771 3 ▶sub term_signal ($self) { $self->{term_signal} }
Subroutine term_signal: called CC=1 SCAR=0.0
Pod documented
772 1 ▶sub core_dumped ($self) { !!$self->{core_dumped} }
Subroutine core_dumped: called CC=1 SCAR=0.0
Pod documented
773 3 ▶sub exited ($self) { $self->{state} eq 'exited' }
Subroutine exited: called CC=1 SCAR=0.0
Pod documented
774 3 ▶sub is_running ($self) { $self->{state} eq 'running' }
Subroutine is_running: called CC=1 SCAR=0.0
Pod documented
775 169 ▶sub is_terminal ($self) {
Subroutine is_terminal: called CC=4 SCAR=14.9
Pod documented
776 return $self->{state} eq 'exited' || $self->{state} eq 'failed'
777 169 ▶ || $self->{state} eq 'not_inherited' || $self->{state} eq 'moved';
Condition66%6/9
$self->{'state'} eq 'exited' || $self->{'state'} eq 'failed' || $self->{'state'} eq 'not_inherited' || $self->{'state'} eq 'moved'
l!l&&r!l&&!r
310138
$self->{"state"} eq "exited" or $self->{"state"} eq "failed" or $self->{"state"} eq "not_inherited"
l!l&&r!l&&!r
310138
$self->{"state"} eq "exited" or $self->{"state"} eq "failed"
l!l&&r!l&&!r
310138
MC/DC25%1/4
$self->{'state'} eq 'exited' || $self->{'state'} eq 'failed' || $self->{'state'} eq 'not_inherited' || $self->{'state'} eq 'moved'
$self->{"state"} eq "exited" $self->{"state"} eq "failed" $self->{"state"} eq "not_inherited" $self->{'state'} eq 'moved'
Truth table40%2/5
A or B or C || D
A= $self->{"state"} eq "exited"B= $self->{"state"} eq "failed"C= $self->{"state"} eq "not_inherited"D= $self->{'state'} eq 'moved'
ABCDresult
1XXX1
01XX1
001X1
00011
00000
778 }
779 5 ▶sub pending_stdin_bytes ($self) { $self->{pending_stdin_bytes} }
Subroutine pending_stdin_bytes: called CC=1 SCAR=0.0
Pod documented
780  
781 194 ▶sub data ($self, @argument) {
Subroutine data: called CC=2 SCAR=7.2
Pod documented
782 194 ▶ $self->{data} = $argument[0] if @argument;
Branch: 1 branch
BranchTrueFalseTotal
if @argument 0 194 194
783 194 return $self->{data};
784 }
785  
786 0 ▶sub CLONE_SKIP ($class) { 1 }
Subroutine CLONE_SKIP: not called CC=1 SCAR=6.9
787  
788 32 ▶sub DESTROY ($self) {
Subroutine DESTROY: called CC=2 SCAR=6.9
789 32 ▶ $self->_release_handles if !$self->is_terminal;
Branch: 1 branch
BranchTrueFalseTotal
unless $self->is_terminal 2 30 32
790 32 return;
791 }
792  
793 13 1;
794 __END__
« bench/run-stream-payload-sweep.pl ↑ Summary blib/lib/Linux/Event/_Socket/Stream.pm »