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

filter: Statementstmt 82.7% 134 / 162 Branchbran 55.5% 50 / 90 Conditioncond 36.4% 27 / 74 MC/DCmcdc 7.8% 3 / 38 Subroutinesub 84.8% 28 / 33 Podpod 87.5% 7 / 8 totaltotal 61.4% 249 / 405 CC 74 SCAR 25.6
CC
74
Cov
65%
_fork_preflight
56.0
_fork_child_drop
30.0
CLONE
30.0
CRAP 12.9
« blib/lib/Linux/Event/Loop/Introspection.pm ↑ Summary blib/lib/Linux/Event/Framer.pm »
1 package Linux::Event::Kernel::Event;
2 14 ▶use v5.36;
Subroutine BEGIN: called CC=1 SCAR=0.0
3 14 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 14 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
5  
6 14 our $VERSION = '0.119';
7  
8 14 ▶use Carp qw(croak);
Subroutine BEGIN: called CC=1 SCAR=0.0
9 14 ▶use Config ();
Subroutine BEGIN: called CC=1 SCAR=0.0
10 14 ▶use POSIX qw(getpid);
Subroutine BEGIN: called CC=1 SCAR=0.0
11 14 ▶use Scalar::Util qw(refaddr weaken);
Subroutine BEGIN: called CC=1 SCAR=0.0
12  
13 14 require Linux::Event::Loop;
14 14 require XSLoader;
15 14 XSLoader::load(__PACKAGE__, $VERSION);
16  
17 14 my %CLASS_DESCRIPTOR;
18 my %OWNER_STATE;
19 14 my %LIVE_HANDLE;
20 14 my $NEXT_ID = 1;
21 14 ▶my $MAX_INCREMENT = $Config::Config{uvsize} >= 8
Branch: 1 branch
BranchTrueFalseTotal
$Config::Config{'uvsize'} >= 8 ? : 14 0 14
22 ? '18446744073709551614' : '4294967295';
23  
24 46 ▶sub _decimal_greater_than ($value, $maximum) {
Subroutine _decimal_greater_than: called CC=4 SCAR=14.1
25 46 $value =~ s/\A0+//;
26 46 ▶ $value = '0' if $value eq '';
Branch: 1 branch
BranchTrueFalseTotal
if $value eq "" 0 46 46
27 46 ▶ return 1 if length($value) > length($maximum);
Branch: 1 branch
BranchTrueFalseTotal
if length $value > length $maximum 0 46 46
28 46 ▶ return 0 if length($value) < length($maximum);
Branch: 1 branch
BranchTrueFalseTotal
if length $value < length $maximum 45 1 46
29 1 return $value gt $maximum;
30 }
31  
32 13 ▶sub _descriptor_for ($class) {
Subroutine _descriptor_for: called CC=4 SCAR=13.9
33 13 ▶ return $CLASS_DESCRIPTOR{$class} if exists $CLASS_DESCRIPTOR{$class};
Branch: 1 branch
BranchTrueFalseTotal
if exists $CLASS_DESCRIPTOR{$class} 3 10 13
34 10 ▶ croak "$class is not a Linux::Event::Kernel::Event subclass"
Branch: 1 branch
BranchTrueFalseTotal
unless $class->isa(__PACKAGE__) 0 10 10
35 if !$class->isa(__PACKAGE__);
36 10 ▶ my $callback = $class->can('on_event')
Condition100%2/2
$class->can("on_event") // croak("$class must define on_event() or receive on_event => coderef")
l!l
73
MC/DC100%1/1
$class->can("on_event") // croak("$class must define on_event() or receive on_event => coderef")
$class->can("on_event")
Truth table100%2/2
A
A= $class->can("on_event")
Aresult
11
00
37 // croak "$class must define on_event() or receive on_event => coderef";
38 7 return $CLASS_DESCRIPTOR{$class} = { callback => $callback };
39 }
40  
41 16 ▶sub _effective_descriptor ($class, $option) {
Subroutine _effective_descriptor: called CC=4 SCAR=13.9
42 16 ▶ croak "$class is not a Linux::Event::Kernel::Event subclass"
Branch: 1 branch
BranchTrueFalseTotal
unless $class->isa(__PACKAGE__) 0 16 16
43 if !$class->isa(__PACKAGE__);
44 16 ▶ return _descriptor_for($class) if !exists $option->{on_event};
Branch: 1 branch
BranchTrueFalseTotal
unless exists $option->{"on_event"} 13 3 16
45 3 my $callback = delete $option->{on_event};
46 3 ▶ croak 'new(): on_event must be a coderef' if ref($callback) ne 'CODE';
Branch: 1 branch
BranchTrueFalseTotal
if ref $callback ne "CODE" 1 2 3
47 2 return { callback => $callback };
48 }
49  
50 16 ▶sub new ($class, %option) {
Subroutine new: called CC=8 SCAR=22.2
Pod undocumented
51 16 ▶ croak 'new(): must be called as a class method' if ref $class;
Branch: 1 branch
BranchTrueFalseTotal
if ref $class 0 16 16
52 16 my $descriptor = _effective_descriptor($class, \%option);
53 12 my $loop = delete $option{loop};
54 12 ▶ 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 12 12
Condition44%4/9
defined $loop and not ref $loop && $loop->can("add") && $loop->can("watch")
!ll&&!rl&&r
660
ref $loop && $loop->can('add') && $loop->can('watch')
!ll&&!rl&&r
006
ref $loop and $loop->can("add")
!ll&&!rl&&r
006
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
55 if defined($loop) && (!ref($loop) || !$loop->can('add')
56 || !$loop->can('watch'));
57 12 my $data = delete $option{data};
58 12 ▶ croak 'new(): unknown options: ' . join(', ', sort keys %option)
Branch: 1 branch
BranchTrueFalseTotal
if %option 0 12 12
59 if %option;
60 12 my $id = $NEXT_ID++;
61 12 my $self = bless {
62 id => $id,
63 fd => _new_fd(),
64 terminal => 0,
65 owner_pid => $$,
66 owner_interpreter => _interpreter_id(),
67 handle_interpreter => _interpreter_id(),
68 cloned_signal_handle => 0,
69 }, $class;
70 12 $LIVE_HANDLE{$id} = $self;
71 12 weaken($LIVE_HANDLE{$id});
72 12 $OWNER_STATE{$id} = bless {
73 descriptor => $descriptor,
74 loop => undef,
75 watcher => undef,
76 data => $data,
77 state => 'unattached',
78 }, 'Linux::Event::Kernel::Event::_OwnerState';
79 12 ▶ $loop->add($self) if defined $loop;
Branch: 1 branch
BranchTrueFalseTotal
if defined $loop 6 6 12
80 12 return $self;
81 }
82  
83 117 ▶sub _assert_owner ($self, $method) {
Subroutine _assert_owner: called CC=4 SCAR=17.9
84 croak "$method(): Event may be managed only by its creating interpreter"
85 if $self->{cloned_signal_handle}
86 || $self->{owner_pid} != $$
87 117 ▶ || $self->{owner_interpreter} != _interpreter_id();
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"cloned_signal_handle"} or $self->{"owner_pid"} != $$ or $self->{"owner_interpreter"} != _interpreter_id() 0 117 117
Condition33%2/6
$self->{"cloned_signal_handle"} or $self->{"owner_pid"} != $$ or $self->{"owner_interpreter"} != _interpreter_id()
l!l&&r!l&&!r
00117
$self->{"cloned_signal_handle"} or $self->{"owner_pid"} != $$
l!l&&r!l&&!r
00117
MC/DC0%0/3
$self->{"cloned_signal_handle"} or $self->{"owner_pid"} != $$ or $self->{"owner_interpreter"} != _interpreter_id()
$self->{"cloned_signal_handle"} $self->{"owner_pid"} != $$ $self->{"owner_interpreter"} != _interpreter_id()
Truth table25%1/4
A or B or C
A= $self->{"cloned_signal_handle"}B= $self->{"owner_pid"} != $$C= $self->{"owner_interpreter"} != _interpreter_id()
ABCresult
1XX1
01X1
0011
0000
88 117 return;
89 }
90  
91 117 ▶sub _owner_state ($self, $method) {
Subroutine _owner_state: called CC=2 SCAR=7.2
92 117 $self->_assert_owner($method);
93 return $OWNER_STATE{ $self->{id} }
94 117 ▶ // croak "$method(): Event owner state is unavailable";
Condition50%1/2
$OWNER_STATE{$self->{"id"}} // croak("$method(): Event owner state is unavailable")
l!l
1170
MC/DC0%0/1
$OWNER_STATE{$self->{"id"}} // croak("$method(): Event owner state is unavailable")
$OWNER_STATE{$self->{"id"}}
Truth table50%1/2
A
A= $OWNER_STATE{$self->{"id"}}
Aresult
11
00
95 }
96  
97 13 ▶sub _attach_to_loop ($self, $loop) {
Subroutine _attach_to_loop: called CC=4 SCAR=14.4
98 13 ▶ croak 'add(): Event is not unattached' if $self->{terminal};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"terminal"} 1 12 13
99 12 my $state = $self->_owner_state('add');
100 croak 'add(): Event is not unattached'
101 12 ▶ if $state->{state} ne 'unattached' || $state->{loop};
Branch: 1 branch
BranchTrueFalseTotal
if $state->{"state"} ne "unattached" or $state->{"loop"} 0 12 12
Condition33%1/3
$state->{"state"} ne "unattached" or $state->{"loop"}
l!l&&r!l&&!r
0012
MC/DC0%0/2
$state->{"state"} ne "unattached" or $state->{"loop"}
$state->{"state"} ne "unattached" $state->{"loop"}
Truth table33%1/3
A or B
A= $state->{"state"} ne "unattached"B= $state->{"loop"}
ABresult
1X1
011
000
102 my $watcher = $loop->watch(
103 fd => $self->{fd},
104 _internal => 1,
105 30 ▶ read => sub { $self->_dispatch },
Subroutine __ANON__: called CC=1 SCAR=0.0
106 0 ▶ error => sub { die "Linux::Event Event event source failed\n" },
Subroutine __ANON__: not called CC=1 SCAR=6.9
107 12 no_args => 1,
108 lean => 1,
109 );
110 11 $state->{loop} = $loop;
111 11 $state->{state} = 'active';
112 11 $state->{watcher} = $watcher;
113 11 return $self;
114 }
115  
116 30 ▶sub _dispatch ($self) {
Subroutine _dispatch: called CC=3 SCAR=11.2
117 30 my $state = $self->_owner_state('dispatch');
118 30 ▶ return if $state->{state} ne 'active';
Branch: 1 branch
BranchTrueFalseTotal
if $state->{"state"} ne "active" 0 30 30
119 30 my $count = _drain_fd($self->{fd});
120 30 ▶ return if !$count;
Branch: 1 branch
BranchTrueFalseTotal
unless $count 0 30 30
121 30 $state->{descriptor}{callback}->($self, $count);
122 29 return;
123 }
124  
125 49 ▶sub signal ($self, $increment = 1) {
Subroutine signal: called CC=9 SCAR=22.4
Pod documented
126 49 ▶ croak 'signal(): Event is cancelled' if $self->{terminal};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"terminal"} 1 48 49
127 croak 'signal(): cloned Event handle belongs to another interpreter'
128 48 ▶ if $self->{handle_interpreter} != _interpreter_id();
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"handle_interpreter"} != _interpreter_id() 0 48 48
129 48 ▶ croak 'signal(): increment must be a positive integer'
Branch: 1 branch
BranchTrueFalseTotal
if not defined $increment or ref $increment or not $increment =~ /\A\d+\z/u or $increment == 0 2 46 48
Condition66%6/9
not defined $increment or ref $increment or not $increment =~ /\A\d+\z/u or $increment == 0
l!l&&r!l&&!r
1146
not defined $increment or ref $increment or not $increment =~ /\A\d+\z/u
l!l&&r!l&&!r
0147
not defined $increment or ref $increment
l!l&&r!l&&!r
0048
MC/DC50%2/4
not defined $increment or ref $increment or not $increment =~ /\A\d+\z/u or $increment == 0
not defined $increment ref $increment not $increment =~ /\A\d+\z/u $increment == 0
Truth table60%3/5
not(A) or B or not(C) or D
A= not defined $incrementB= ref $incrementC= not $increment =~ /\A\d+\z/uD= $increment == 0
ABCDresult
1XXX1
01XX1
001X1
00011
00000
130 if !defined($increment) || ref($increment)
131 || $increment !~ /\A\d+\z/ || $increment == 0;
132 46 ▶ croak 'signal(): increment exceeds the supported eventfd range'
Branch: 1 branch
BranchTrueFalseTotal
if _decimal_greater_than("$increment", $MAX_INCREMENT) 1 45 46
133 if _decimal_greater_than("$increment", $MAX_INCREMENT);
134 45 _signal_fd($self->{fd}, 0 + $increment);
135 45 return $self;
136 }
137  
138 13 ▶sub cancel ($self) {
Subroutine cancel: called CC=4 SCAR=13.9
Pod documented
139 13 ▶ return $self if $self->{terminal};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"terminal"} 1 12 13
140 12 my $state = $self->_owner_state('cancel');
141 12 ▶ $state->{watcher}->cancel if $state->{watcher};
Branch: 1 branch
BranchTrueFalseTotal
if $state->{"watcher"} 11 1 12
142 12 $state->{watcher} = undef;
143 12 ▶ _close_fd(delete $self->{fd}) if defined $self->{fd};
Branch: 1 branch
BranchTrueFalseTotal
if defined $self->{"fd"} 12 0 12
144 12 delete $LIVE_HANDLE{ $self->{id} };
145 12 $state->{loop} = undef;
146 12 $state->{data} = undef;
147 12 $state->{state} = 'cancelled';
148 12 delete $OWNER_STATE{ $self->{id} };
149 12 $self->{terminal} = 1;
150 12 return $self;
151 }
152  
153 31 ▶sub loop ($self) {
Subroutine loop: called CC=2 SCAR=6.9
Pod documented
154 31 ▶ return undef if $self->{terminal};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"terminal"} 1 30 31
155 30 return $self->_owner_state('loop')->{loop};
156 }
157 7 ▶sub state ($self) {
Subroutine state: called CC=4 SCAR=14.2
Pod documented
158 7 ▶ return $self->{fork_state} if $self->{terminal} && $self->{fork_state};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"terminal"} and $self->{"fork_state"} 0 7 7
Condition66%2/3
$self->{"terminal"} and $self->{"fork_state"}
!ll&&!rl&&r
610
MC/DC0%0/2
$self->{"terminal"} and $self->{"fork_state"}
$self->{"terminal"} $self->{"fork_state"}
Truth table66%2/3
A and B
A= $self->{"terminal"}B= $self->{"fork_state"}
ABresult
0X0
100
111
159 7 ▶ return 'cancelled' if $self->{terminal};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"terminal"} 1 6 7
160 6 return $self->_owner_state('state')->{state};
161 }
162 2 ▶sub is_active ($self) { $self->state eq 'active' }
Subroutine is_active: called CC=1 SCAR=0.0
Pod documented
163 28 ▶sub is_terminal ($self) { !!$self->{terminal} }
Subroutine is_terminal: called CC=1 SCAR=0.0
Pod documented
164  
165 27 ▶sub data ($self, @argument) {
Subroutine data: called CC=3 SCAR=11.4
Pod documented
166 27 ▶ croak 'data(): Event is cancelled' if $self->{terminal};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"terminal"} 0 27 27
167 27 my $state = $self->_owner_state('data');
168 27 ▶ $state->{data} = $argument[0] if @argument;
Branch: 1 branch
BranchTrueFalseTotal
if @argument 0 27 27
169 27 return $state->{data};
170 }
171  
172 0 ▶sub _fork_preflight ($self, $mode, $loop) {
Subroutine _fork_preflight: not called CC=7 SCAR=40.3
173 0 ▶ croak "fork(): Event does not support '$mode'" if $mode ne 'drop';
Branch: 1 branch
BranchTrueFalseTotal
if $mode ne "drop" 0 0 0
174 0 my $state = $OWNER_STATE{ $self->{id} };
175 croak 'fork(): Event is not active in this Loop'
176 if $self->{terminal} || !$state || !$state->{loop}
177 || refaddr($state->{loop}) != refaddr($loop)
178 0 ▶ || $state->{state} ne 'active';
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"terminal"} or not $state or not $state->{"loop"} or builtin::refaddr($state->{"loop"}) != builtin::refaddr($loop) or $state->{"state"} ne "active" 0 0 0
Condition0%0/12
$self->{"terminal"} or not $state or not $state->{"loop"} or builtin::refaddr($state->{"loop"}) != builtin::refaddr($loop) or $state->{"state"} ne "active"
l!l&&r!l&&!r
000
$self->{"terminal"} or not $state or not $state->{"loop"} or builtin::refaddr($state->{"loop"}) != builtin::refaddr($loop)
l!l&&r!l&&!r
000
$self->{"terminal"} or not $state or not $state->{"loop"}
l!l&&r!l&&!r
000
$self->{"terminal"} or not $state
l!l&&r!l&&!r
000
MC/DC0%0/5
$self->{"terminal"} or not $state or not $state->{"loop"} or builtin::refaddr($state->{"loop"}) != builtin::refaddr($loop) or $state->{"state"} ne "active"
$self->{"terminal"} not $state not $state->{"loop"} builtin::refaddr($state->{"loop"}) != builtin::refaddr($loop) $state->{"state"} ne "active"
Truth table0%0/6
A or not(B) or not(C) or D or E
A= $self->{"terminal"}B= not $stateC= not $state->{"loop"}D= builtin::refaddr($state->{"loop"}) != builtin::refaddr($loop)E= $state->{"state"} ne "active"
ABCDEresult
1XXXX1
01XXX1
001XX1
0001X1
000011
000000
179 0 return 1;
180 }
181  
182 0 ▶sub _fork_child_drop ($self, $loop) {
Subroutine _fork_child_drop: not called CC=5 SCAR=34.0
183 0 my $state = delete $OWNER_STATE{ $self->{id} };
184 0 ▶ $state->{watcher} = undef if $state;
Branch: 1 branch
BranchTrueFalseTotal
if $state 0 0 0
185 0 ▶ $state->{loop} = undef if $state;
Branch: 1 branch
BranchTrueFalseTotal
if $state 0 0 0
186 0 ▶ $state->{data} = undef if $state;
Branch: 1 branch
BranchTrueFalseTotal
if $state 0 0 0
187 0 ▶ _close_fd(delete $self->{fd}) if defined $self->{fd};
Branch: 1 branch
BranchTrueFalseTotal
if defined $self->{"fd"} 0 0 0
188 0 delete $LIVE_HANDLE{ $self->{id} };
189 0 $self->{owner_pid} = getpid();
190 0 $self->{terminal} = 1;
191 0 $self->{fork_state} = 'not_inherited';
192 0 return;
193 }
194  
195 69 ▶sub _objects_for_loop ($class, $loop) {
Subroutine _objects_for_loop: called CC=7 SCAR=21.5
196 69 my @object;
197 69 for my $id (keys %LIVE_HANDLE) {
198 26 ▶ my $object = $LIVE_HANDLE{$id} // next;
Condition50%1/2
$LIVE_HANDLE{$id} // (next)
l!l
260
MC/DC0%0/1
$LIVE_HANDLE{$id} // (next)
$LIVE_HANDLE{$id}
Truth table50%1/2
A
A= $LIVE_HANDLE{$id}
Aresult
11
00
199 26 ▶ next if $object->{terminal};
Branch: 1 branch
BranchTrueFalseTotal
if $object->{"terminal"} 0 26 26
200 26 ▶ my $state = $OWNER_STATE{$id} // next;
Condition50%1/2
$OWNER_STATE{$id} // (next)
l!l
260
MC/DC0%0/1
$OWNER_STATE{$id} // (next)
$OWNER_STATE{$id}
Truth table50%1/2
A
A= $OWNER_STATE{$id}
Aresult
11
00
201 next if !$state->{loop}
202 26 ▶ || refaddr($state->{loop}) != refaddr($loop);
Branch: 1 branch
BranchTrueFalseTotal
if not $state->{"loop"} or builtin::refaddr($state->{"loop"}) != builtin::refaddr($loop) 0 26 26
Condition33%1/3
not $state->{"loop"} or builtin::refaddr($state->{"loop"}) != builtin::refaddr($loop)
l!l&&r!l&&!r
0026
MC/DC0%0/2
not $state->{"loop"} or builtin::refaddr($state->{"loop"}) != builtin::refaddr($loop)
not $state->{"loop"} builtin::refaddr($state->{"loop"}) != builtin::refaddr($loop)
Truth table33%1/3
not(A) or B
A= not $state->{"loop"}B= builtin::refaddr($state->{"loop"}) != builtin::refaddr($loop)
ABresult
1X1
011
000
203 26 push @object, $object;
204 }
205 69 return \@object;
206 }
207  
208 0 ▶sub CLONE ($class) {
Subroutine CLONE: not called CC=5 SCAR=34.0
209 0 for my $id (keys %LIVE_HANDLE) {
210 0 my $self = $LIVE_HANDLE{$id};
211 0 ▶ if (!$self) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self) 0 0 0
212 0 delete $LIVE_HANDLE{$id};
213 0 next;
214 }
215 0 ▶ next if $self->{terminal} || !defined $self->{fd};
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"terminal"} or not defined $self->{"fd"} 0 0 0
Condition0%0/3
$self->{"terminal"} or not defined $self->{"fd"}
l!l&&r!l&&!r
000
MC/DC0%0/2
$self->{"terminal"} or not defined $self->{"fd"}
$self->{"terminal"} not defined $self->{"fd"}
Truth table0%0/3
A or not(B)
A= $self->{"terminal"}B= not defined $self->{"fd"}
ABresult
1X1
011
000
216 0 $self->{fd} = _dup_fd($self->{fd});
217 0 $self->{handle_interpreter} = _interpreter_id();
218 0 $self->{cloned_signal_handle} = 1;
219 }
220 0 return;
221 }
222  
223 12 ▶sub DESTROY ($self) {
Subroutine DESTROY: called CC=12 SCAR=32.0
224 12 my $interpreter = eval { _interpreter_id() };
225 my $is_owner = !$self->{cloned_signal_handle}
226 && defined($interpreter)
227 && $self->{owner_pid} == $$
228 12 ▶ && $self->{owner_interpreter} == $interpreter;
Condition33%3/9
!$self->{'cloned_signal_handle'} && defined $interpreter && $self->{'owner_pid'} == $$ && $self->{'owner_interpreter'} == $interpreter
!ll&&!rl&&r
0012
not $self->{"cloned_signal_handle"} and defined $interpreter and $self->{"owner_pid"} == $$
!ll&&!rl&&r
0012
not $self->{"cloned_signal_handle"} and defined $interpreter
!ll&&!rl&&r
0012
MC/DC0%0/4
!$self->{'cloned_signal_handle'} && defined $interpreter && $self->{'owner_pid'} == $$ && $self->{'owner_interpreter'} == $interpreter
not $self->{"cloned_signal_handle"} defined $interpreter $self->{"owner_pid"} == $$ $self->{'owner_interpreter'} == $interpreter
Truth table20%1/5
not(A) and B and C && D
A= not $self->{"cloned_signal_handle"}B= defined $interpreterC= $self->{"owner_pid"} == $$D= $self->{'owner_interpreter'} == $interpreter
ABCDresult
0XXX0
10XX0
110X0
11100
11111
229 12 ▶ if ($is_owner) {
Branch: 1 branch
BranchTrueFalseTotal
if ($is_owner) 12 0 12
230 12 my $state = delete $OWNER_STATE{ $self->{id} };
231 12 ▶ eval { $state->{watcher}->cancel if $state && $state->{watcher}; 1 };
Branch: 1 branch
BranchTrueFalseTotal
if $state and $state->{"watcher"} 0 12 12
Condition33%1/3
$state and $state->{"watcher"}
!ll&&!rl&&r
1200
MC/DC0%0/2
$state and $state->{"watcher"}
$state $state->{"watcher"}
Truth table33%1/3
A and B
A= $stateB= $state->{"watcher"}
ABresult
0X0
100
111
232 }
233 12 my $live = $LIVE_HANDLE{ $self->{id} };
234 delete $LIVE_HANDLE{ $self->{id} }
235 12 ▶ if !$live || refaddr($live) == refaddr($self);
Branch: 1 branch
BranchTrueFalseTotal
if not $live or builtin::refaddr($live) == builtin::refaddr($self) 12 0 12
Condition33%1/3
not $live or builtin::refaddr($live) == builtin::refaddr($self)
l!l&&r!l&&!r
1200
MC/DC0%0/2
not $live or builtin::refaddr($live) == builtin::refaddr($self)
not $live builtin::refaddr($live) == builtin::refaddr($self)
Truth table33%1/3
not(A) or B
A= not $liveB= builtin::refaddr($live) == builtin::refaddr($self)
ABresult
1X1
011
000
236 return if !defined($interpreter)
237 12 ▶ || $self->{handle_interpreter} != $interpreter;
Branch: 1 branch
BranchTrueFalseTotal
if not defined $interpreter or $self->{"handle_interpreter"} != $interpreter 0 12 12
Condition33%1/3
not defined $interpreter or $self->{"handle_interpreter"} != $interpreter
l!l&&r!l&&!r
0012
MC/DC0%0/2
not defined $interpreter or $self->{"handle_interpreter"} != $interpreter
not defined $interpreter $self->{"handle_interpreter"} != $interpreter
Truth table33%1/3
not(A) or B
A= not defined $interpreterB= $self->{"handle_interpreter"} != $interpreter
ABresult
1X1
011
000
238 0 ▶ eval { _close_fd(delete $self->{fd}); 1 } if defined $self->{fd};
Branch: 1 branch
BranchTrueFalseTotal
if defined $self->{"fd"} 0 12 12
239 12 return;
240 }
241  
242 package Linux::Event::Kernel::Event::_OwnerState;
243 14 ▶use v5.36;
Subroutine BEGIN: called CC=1 SCAR=0.0
244 14 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
245 14 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
246  
247 0 ▶sub CLONE_SKIP ($class) { 1 }
Subroutine CLONE_SKIP: not called CC=1 SCAR=6.9
248  
249 package Linux::Event::Kernel::Event;
250  
251 14 1;
252 __END__
« blib/lib/Linux/Event/Loop/Introspection.pm ↑ Summary blib/lib/Linux/Event/Framer.pm »