Branch Coverage

File:blib/lib/Params/Validate/Strict.pm
Coverage:76.5%

line%coveragebranch
962100TFunless (defined $unknown_parameter_handler)
96350TFif ($params->{'carp_on_warn'}) { }
970100TFunless defined $schema
973100TFif (ref $schema ne "HASH")
98150TFif ($schema->{'members'} and $schema->{'description'} || $schema->{'error_msg'})
987100TFif (exists $params->{'args'} and not defined $args) { }
100TFelsif (ref $args ne 'HASH' and ref $args ne 'ARRAY') { }
993100TFif (ref $args eq "HASH")
996100TFunless (exists $schema->{$key})
997100TFif ($unknown_parameter_handler eq 'die') { }
100TFelsif ($unknown_parameter_handler eq 'warn') { }
100TFelsif ($unknown_parameter_handler eq 'ignore') { }
1003100TFif ($logger)
1017100TFif (defined(my $rules = $schema->{$key})) { }
1018100TFif (ref $rules eq 'HASH') { }
1019100TFunless (defined $rules->{'position'})
102050TFif ($are_positional_args == 1)
1042100TFif ($are_positional_args == 1) { }
104350TFif (ref $args ne "ARRAY")
1051100TFunless (defined $rules)
1057100TFif (ref $rules eq "")
1065100TFif (ref $rules eq "HASH")
106650TFif (exists $rules->{'description'})
1069100TFif ($rules->{'transform'} and defined $value)
1070100TFif (ref $rules->{'transform'} eq 'CODE') { }
1076100TFif (exists $rules->{'optional'}) { }
50TFelsif ($rules->{'nullable'}) { }
1077100TFif (ref $rules->{'optional'} eq 'CODE') { }
1088100TFif (ref $rules eq 'HASH' and $is_optional) { }
100TFelsif (ref $args eq 'HASH' and not exists $args->{$key}) { }
1090100TFif ($are_positional_args == 1) { }
1092100TFunless (defined $$args[$rules->{'position'}])
1096100TFunless (exists $args->{$key})
1100100TFif ($look_for_default)
1101100TFif ($are_positional_args == 1)
110250TFif (scalar @{$args;} < $rules->{'position'})
1108100TFif (exists $rules->{'default'})
1113100TFif ($rules->{'schema'}) { }
1115100TFunless scalar %{$value;}
1127100TFif (ref $rules eq 'HASH') { }
100TFelsif (ref $rules eq 'ARRAY') { }
50TFelsif (ref $rules) { }
1128100TFif (defined(my $min = $rules->{'min'} // $rules->{'minimum'}) and defined(my $max = $rules->{'max'}))
1129100TFif ($min > $max)
1134100TFif ($rules->{'memberof'})
1135100TFif (defined(my $min = $rules->{'min'} // $rules->{'minimum'}))
1138100TFif (defined(my $max = $rules->{'max'}))
1146100TFif (ref $rule_value eq "CODE" and $rule_name ne "validate" and $rule_name ne "callback" and $rule_name ne "validator")
115150TFif (&Scalar::Util::blessed($rule_value) and $rule_value->can("as_string"))
1155100TFif ($rule_name eq 'type') { }
100TFelsif ($rule_name eq 'min' or $rule_name eq 'minimum') { }
100TFelsif ($rule_name eq 'max') { }
100TFelsif ($rule_name eq 'matches') { }
100TFelsif ($rule_name eq 'nomatch') { }
100TFelsif ($rule_name eq 'memberof' or $rule_name eq 'enum') { }
100TFelsif ($rule_name eq 'notmemberof') { }
100TFelsif ($rule_name eq 'isa') { }
100TFelsif ($rule_name eq 'can') { }
100TFelsif ($rule_name eq 'element_type') { }
100TFelsif ($rule_name eq 'optional') { }
100TFelsif ($rule_name eq 'default') { }
100TFelsif ($rule_name eq 'error_msg') { }
100TFelsif ($rule_name eq 'transform') { }
100TFelsif ($rule_name eq 'case_sensitive') { }
50TFelsif ($rule_name eq 'description') { }
50TFelsif ($rule_name =~ /^_/) { }
100TFelsif ($rule_name eq 'semantic') { }
100TFelsif ($rule_name eq 'schema') { }
100TFelsif ($rule_name eq 'validate' or $rule_name eq 'validator') { }
100TFelsif ($rule_name eq 'callback') { }
50TFelsif ($rule_name eq 'position') { }
1158100TFif ($type eq 'string' or $type eq 'str') { }
100TFelsif ($type eq 'integer') { }
100TFelsif ($type eq 'number' or $type eq 'float') { }
100TFelsif ($type eq 'arrayref') { }
100TFelsif ($type eq 'hashref') { }
100TFelsif ($type eq 'boolean' or $type eq 'bool') { }
100TFelsif ($type eq 'coderef') { }
100TFelsif ($type eq 'object') { }
100TFelsif (my $custom_type = $custom_types->{$type}) { }
1159100TFif (ref $value)
11620TFunless (ref $value eq "" or defined $value and length $value)
1166100TFunless (defined $value)
1169100TFunless ($value =~ /^\s*[+\-]?\d+\s*$/)
1170100TFif ($rules->{'error_msg'}) { }
1178100TFunless (defined $value)
1181100TFunless (&Scalar::Util::looks_like_number($value))
118250TFif ($rules->{'error_msg'}) { }
1191100TFunless (defined $value)
119450TFif (ref $value ne "ARRAY")
11950TFif ($rules->{'error_msg'}) { }
1202100TFunless (defined $value)
120550TFif (ref $value ne "HASH")
12060TFif ($rules->{'error_msg'}) { }
1213100TFunless (defined $value)
1216100TFif (defined(my $b = $Readonly::Values::Boolean::booleans{$value})) { }
121950TFif ($rules->{'error_msg'}) { }
1226100TFunless (defined $value)
122950TFif (ref $value ne "CODE")
12300TFif ($rules->{'error_msg'}) { }
1237100TFunless (defined $value)
1240100TFunless (&Scalar::Util::blessed($value))
124150TFif ($rules->{'error_msg'}) { }
1248100TFif ($custom_type->{'transform'})
125050TFif (ref $custom_type->{'transform'} eq 'CODE') { }
126250TFunless (defined $rules->{'type'})
1266100TFif (exists $custom_types->{$type}{'min'} or exists $custom_types->{$type}{'minimum'})
1270100TFif ($type eq 'string' or $type eq 'str') { }
100TFelsif ($type eq 'arrayref') { }
100TFelsif ($type eq 'hashref') { }
100TFelsif ($type eq 'integer' or $type eq 'number' or $type eq 'float') { }
1271100TFif ($rule_value < 0)
127250TFif ($rules->{'error_msg'}) { }
127850TFunless (defined $value)
128150TFif (defined(my $len = _number_of_characters($value))) { }
1282100TFif ($len < $rule_value)
129150TFunless (defined $value)
129450TFif (ref $value ne "ARRAY")
12950TFif ($rules->{'error_msg'}) { }
1301100TFif (scalar @{$value;} < $rule_value)
130250TFif ($rules->{'error_msg'}) { }
131050TFunless (defined $value)
1313100TFif (scalar keys %{$value;} < $rule_value)
131450TFif ($rules->{'error_msg'}) { }
132250TFunless (defined $value)
1325100TFif (&Scalar::Util::looks_like_number($value)) { }
1326100TFif ($value < $rule_value)
1327100TFif ($rules->{'error_msg'}) { }
133650TFif ($rules->{'error_msg'}) { }
134750TFunless (defined $rules->{'type'})
1351100TFif (exists $custom_types->{$type}{'max'})
1355100TFif ($type eq 'string' or $type eq 'str') { }
100TFelsif ($type eq 'arrayref') { }
100TFelsif ($type eq 'hashref') { }
100TFelsif ($type eq 'integer' or $type eq 'number' or $type eq 'float') { }
135650TFunless (defined $value)
135950TFif (defined(my $len = _number_of_characters($value))) { }
1360100TFif ($len > $rule_value)
136950TFunless (defined $value)
137250TFif (ref $value ne "ARRAY")
13730TFif ($rules->{'error_msg'}) { }
1379100TFif (scalar @{$value;} > $rule_value)
138050TFif ($rules->{'error_msg'}) { }
138850TFunless (defined $value)
1391100TFif (scalar keys %{$value;} > $rule_value)
139250TFif ($rules->{'error_msg'}) { }
140050TFunless (defined $value)
140350TFif (&Scalar::Util::looks_like_number($value)) { }
1404100TFif ($value > $rule_value)
140550TFif ($rules->{'error_msg'}) { }
14140TFif ($rules->{'error_msg'}) { }
1425100TFunless (defined $value)
1429100TFref $rule_value eq 'Regexp' ? :
1430100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
100TFelsif (not $value =~ /$re/) { }
143250TFif (scalar @matches != scalar @{$value;})
14330TFif ($rules->{'error_msg'}) { }
1440100TFif ($rules->{'error_msg'}) { }
1448100TFif ($@)
1449100TFif ($rules->{'error_msg'}) { }
145750TFunless (defined $value)
1460100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
100TFelsif ($value =~ /$rule_value/) { }
1462100TFif (scalar @matches)
146350TFif ($rules->{'error_msg'}) { }
147050TFif ($rules->{'error_msg'}) { }
147850TFunless (defined $value)
1481100TFif (ref $rule_value eq 'ARRAY') { }
1483100TFif ($rules->{'type'} eq 'integer' or $rules->{'type'} eq 'number' or $rules->{'type'} eq 'float') { }
1484100TFunless (&List::Util::any(sub {         $_ == $value; } , @{$rule_value;}))
1489100TF!defined($rules->{'case_sensitive'}) || $rules->{'case_sensitive'} == 1 ? :
100TFunless (&List::Util::any(sub {         !defined($rules->{'case_sensitive'}) || $rules->{'case_sensitive'} == 1 ? $_ eq $value : lc $_ eq $l; } , @{$rule_value;}))
1494100TFunless ($ok)
1495100TFif ($rules->{'error_msg'}) { }
150350TFif ($rules->{'error_msg'}) { }
151050TFunless (defined $value)
1513100TFif (ref $rule_value eq 'ARRAY') { }
1515100TFif ($rules->{'type'} eq 'integer' or $rules->{'type'} eq 'number' or $rules->{'type'} eq 'float') { }
1516100TFif (&List::Util::any(sub {         $_ == $value; } , @{$rule_value;}))
152150TF!defined($rules->{'case_sensitive'}) || $rules->{'case_sensitive'} == 1 ? :
100TFif (&List::Util::any(sub {         !defined($rules->{'case_sensitive'}) || $rules->{'case_sensitive'} == 1 ? $_ eq $value : lc $_ eq $l; } , @{$rule_value;}))
1526100TFunless ($ok)
1527100TFif ($rules->{'error_msg'}) { }
153550TFif ($rules->{'error_msg'}) { }
154250TFunless (defined $value)
1545100TFif ($rules->{'type'} eq 'object') { }
1546100TFunless ($value->isa($rule_value))
154750TFref $value ? :
155450TFunless (defined $value)
1557100TFif ($rules->{'type'} eq 'object') { }
1558100TFif (ref $rule_value eq 'ARRAY') { }
100TFelsif (not ref $rule_value) { }
1561100TFunless ($value->can($method))
1567100TFunless ($value->can($rule_value))
157850TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
1581100TFif ($custom_type and $custom_type->{'type'})
1585100TFif ($custom_type and $custom_type->{'transform'})
158750TFif (ref $custom_type->{'transform'} eq 'CODE') { }
1594100TFif ($type eq 'string' or $type eq 'Str') { }
100TFelsif ($type eq 'integer') { }
50TFelsif ($type eq 'number' or $rule_value eq 'float') { }
159550TFif (ref $member)
15960TFif ($rules->{'error_msg'}) { }
1604100TFif (ref $member or $member =~ /\D/)
1605100TFif ($rules->{'error_msg'}) { }
1613100TFif (ref $member or not $member =~ /^[-+]?(\d*\.\d+|\d+\.?\d*)$/)
161450TFif ($rules->{'error_msg'}) { }
164350TFif ($rule_value eq 'unix_timestamp') { }
164450TFif ($value < 0 or $value > 2147483647)
1652100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
50TFelsif ($rules->{'type'} eq 'hashref') { }
1653100TFif (ref $value eq 'ARRAY') { }
50TFelsif (defined $value) { }
165550TFunless (validate_strict({"input", {$key, $member}, "schema", {$key, $rule_value}, "custom_types", $custom_types}))
166350TFif (ref $value eq 'HASH') { }
1666100TFif (scalar keys %{$value;})
166750TFif (my $new_args = validate_strict({'input', $nested_with_defaults, 'schema', $rule_value, 'custom_types', $custom_types})) { }
168050TFif (ref $rule_value eq 'CODE') { }
1681100TFif (my $error = &{$rule_value;}($args))
1691100TFunless (defined &$rule_value)
1695100TFunless ($res)
169650TFif ($rules->{'error_msg'}) { }
170450TFif ($rule_value =~ /\D/)
170750TFif ($rule_value < 0)
1715100TFif (scalar @{$rules;}) { }
1720100TFif (ref $rule ne "HASH")
172450TFunless (defined $rule->{'type'})
1732100TFunless ($@)
1737100TFunless ($rc)
1752100TFif (my $relationships = $params->{'relationships'})
1756100TFif (my $cross_validation = $params->{'cross_validation'})
1759100TFif (not ref $validator or ref $validator ne "CODE")
1763100TFif (my $error = &{$validator;}(\%validated_args, $validator))
1775100TFif ($are_positional_args == 1)
177850TFif (my $value = delete $validated_args{$key})
1780100TFif (defined $rc[$position])
179750TFunless defined $value
1799100TFunless ($value =~ /[^[:ascii:]]/)
180350TFunless utf8::is_utf8($value)
1819100TFif (ref $rules eq "HASH" and exists $rules->{'default'} and not exists $result{$key})
1824100TFif (ref $rules eq "HASH" and $rules->{'schema'} and ref $result{$key} eq "HASH")
183550TFunless ref $relationships eq "ARRAY"
183850TFunless my $type = $rel->{'type'}
1840100TFif ($type eq 'mutually_exclusive') { }
100TFelsif ($type eq 'required_group') { }
100TFelsif ($type eq 'conditional_requirement') { }
100TFelsif ($type eq 'dependency') { }
100TFelsif ($type eq 'value_constraint') { }
50TFelsif ($type eq 'value_conditional') { }
186150TFunless $rel->{'params'}
186250TFunless @params >= 2
186450TFif exists $args->{$_}
186650TFif (@present > 1)
187550TFunless $rel->{'params'}
187650TFunless @params >= 2
187850TFif exists $args->{$_}
188050TFif (@present == 0)
189050TFunless my $if_param = $rel->{'if'}
189150TFunless my $then_param = $rel->{'then_required'}
189450TFif (exists $args->{$if_param} and defined $args->{$if_param})
189650TFif ($args->{$if_param})
189850TFunless (exists $args->{$then_param} and defined $args->{$then_param})
190950TFunless my $param = $rel->{'param'}
191050TFunless my $requires = $rel->{'requires'}
191350TFif (exists $args->{$param} and defined $args->{$param})
191450TFunless (exists $args->{$requires} and defined $args->{$requires})
192450TFunless my $if_param = $rel->{'if'}
192550TFunless my $then_param = $rel->{'then'}
192650TFunless my $operator = $rel->{'operator'}
192850TFunless defined $value
193150TFif (exists $args->{$if_param} and defined $args->{$if_param} and $args->{$if_param})
193350TFif (exists $args->{$then_param} and defined $args->{$then_param})
193750TFif ($operator eq '==') { }
0TFelsif ($operator eq '!=') { }
0TFelsif ($operator eq '<') { }
0TFelsif ($operator eq '<=') { }
0TFelsif ($operator eq '>') { }
0TFelsif ($operator eq '>=') { }
195150TFunless ($valid)
196250TFunless my $if_param = $rel->{'if'}
196450TFunless my $then_param = $rel->{'then_required'}
196550TFunless defined $equals
196850TFif (exists $args->{$if_param} and defined $args->{$if_param})
196950TFif ($args->{$if_param} eq $equals)
197150TFunless (exists $args->{$then_param} and defined $args->{$then_param})
1987100TFif ($logger)
2001100TFif ($logger) { }