Branch Coverage

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

line%coveragebranch
1009100TFunless (defined $unknown_parameter_handler)
1010100TFif ($params->{'carp_on_warn'}) { }
1017100TFunless defined $schema
1021100TFif (ref $schema eq "ARRAY")
1026100TFif (ref $schema ne "HASH")
103450TFif ($schema->{'members'} and $schema->{'description'} || $schema->{'error_msg'})
1039100TFif (ref $schema eq "ARRAY")
1044100TFif (exists $params->{'args'} and not defined $args) { }
100TFelsif (ref $args ne 'HASH' and ref $args ne 'ARRAY') { }
1050100TFif (ref $args eq "HASH")
1053100TFunless (exists $schema->{$key})
1054100TFif ($unknown_parameter_handler eq 'die') { }
100TFelsif ($unknown_parameter_handler eq 'warn') { }
100TFelsif ($unknown_parameter_handler eq 'ignore') { }
1060100TFif ($logger)
1074100TFif (defined(my $rules = $schema->{$key})) { }
1075100TFif (ref $rules eq 'HASH') { }
1076100TFunless (defined $rules->{'position'})
107750TFif ($are_positional_args == 1)
1099100TFif ($are_positional_args == 1) { }
110050TFif (ref $args ne "ARRAY")
1108100TFunless (defined $rules)
1114100TFif (ref $rules eq "")
1122100TFif (ref $rules eq "HASH")
112350TFif (exists $rules->{'description'})
1126100TFif ($rules->{'transform'} and defined $value)
1127100TFif (ref $rules->{'transform'} eq 'CODE') { }
1133100TFif (exists $rules->{'optional'}) { }
100TFelsif ($rules->{'nullable'}) { }
1134100TFif (ref $rules->{'optional'} eq 'CODE') { }
1145100TFif (ref $rules eq 'HASH' and $is_optional) { }
100TFelsif (ref $args eq 'HASH' and not exists $args->{$key}) { }
1147100TFif ($are_positional_args == 1) { }
1149100TFunless (defined $$args[$rules->{'position'}])
1153100TFunless (exists $args->{$key})
1157100TFif ($look_for_default)
1158100TFif ($are_positional_args == 1)
115950TFif (scalar @{$args;} < $rules->{'position'})
1165100TFif (exists $rules->{'default'})
1171100TFif ($rules->{'schema'}) { }
1173100TFunless scalar %{$value;}
1190100TFif (ref $rules eq "HASH" and ref $rules->{'type'} eq "ARRAY")
1193100TFunless (@type_list)
1201100TFif (ref $rules eq 'HASH') { }
100TFelsif (ref $rules eq 'ARRAY') { }
50TFelsif (ref $rules) { }
1202100TFif (defined(my $min = $rules->{'min'} // $rules->{'minimum'}) and defined(my $max = $rules->{'max'}))
1203100TFif ($min > $max)
1209100TFif ($rules->{'memberof'} or $rules->{'enum'} or $rules->{'values'})
1210100TFif (defined(my $min = $rules->{'min'} // $rules->{'minimum'}))
1213100TFif (defined(my $max = $rules->{'max'}))
1221100TFif (ref $rule_value eq "CODE" and $rule_name ne "validate" and $rule_name ne "callback" and $rule_name ne "validator" and $rule_name ne "transform" and $rule_name ne "optional")
123150TFif (&Scalar::Util::blessed($rule_value) and $rule_value->can("as_string"))
1235100TFif ($rule_name eq 'type') { }
100TFelsif ($rule_name eq 'min' or $rule_name eq 'minimum') { }
100TFelsif ($rule_name eq 'max') { }
100TFelsif ($rule_name eq 'matches' or $rule_name eq 'regex') { }
100TFelsif ($rule_name eq 'nomatch') { }
100TFelsif ($rule_name eq 'memberof' or $rule_name eq 'enum' or $rule_name eq 'values') { }
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 'nullable') { }
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') { }
100TFelsif ($rule_name eq 'position') { }
1238100TFif ($type eq 'string' or $type eq 'str') { }
100TFelsif ($type eq 'integer' or $type eq 'int') { }
100TFelsif ($type eq 'number' or $type eq 'float' or $type eq 'num' or $type eq 'double') { }
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}) { }
1239100TFif (ref $value)
12420TFunless (ref $value eq "" or defined $value and length $value)
1246100TFunless (defined $value)
1249100TFunless ($value =~ /^\s*[+\-]?\d+\s*$/)
1250100TFif ($rules->{'error_msg'}) { }
1258100TFunless (defined $value)
1261100TFunless (&Scalar::Util::looks_like_number($value))
126250TFif ($rules->{'error_msg'}) { }
1271100TFunless (defined $value)
1274100TFif (ref $value ne "ARRAY")
127550TFif ($rules->{'error_msg'}) { }
1282100TFunless (defined $value)
1285100TFif (ref $value ne "HASH")
128650TFif ($rules->{'error_msg'}) { }
1293100TFunless (defined $value)
1296100TFif (defined(my $b = $Readonly::Values::Boolean::booleans{$value})) { }
129950TFif ($rules->{'error_msg'}) { }
1306100TFunless (defined $value)
1309100TFif (ref $value ne "CODE")
131050TFif ($rules->{'error_msg'}) { }
1317100TFunless (defined $value)
1320100TFunless (&Scalar::Util::blessed($value))
132150TFif ($rules->{'error_msg'}) { }
1328100TFif ($custom_type->{'transform'})
1330100TFif (ref $custom_type->{'transform'} eq 'CODE') { }
134250TFunless (defined $rules->{'type'})
1346100TFif (exists $custom_types->{$type}{'min'} or exists $custom_types->{$type}{'minimum'})
1350100TFif ($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') { }
1351100TFif ($rule_value < 0)
135250TFif ($rules->{'error_msg'}) { }
1358100TFunless (defined $value)
136150TFif (defined(my $len = _number_of_characters($value))) { }
1362100TFif ($len < $rule_value)
137150TFunless (defined $value)
1374100TFif (ref $value ne "ARRAY")
137550TFif ($rules->{'error_msg'}) { }
1381100TFif (scalar @{$value;} < $rule_value)
138250TFif ($rules->{'error_msg'}) { }
139050TFunless (defined $value)
1393100TFif (scalar keys %{$value;} < $rule_value)
139450TFif ($rules->{'error_msg'}) { }
140250TFunless (defined $value)
1405100TFif (&Scalar::Util::looks_like_number($value)) { }
1406100TFif ($value < $rule_value)
1407100TFif ($rules->{'error_msg'}) { }
141650TFif ($rules->{'error_msg'}) { }
142750TFunless (defined $rules->{'type'})
1431100TFif (exists $custom_types->{$type}{'max'})
1435100TFif ($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') { }
1436100TFunless (defined $value)
143950TFif (defined(my $len = _number_of_characters($value))) { }
1440100TFif ($len > $rule_value)
144950TFunless (defined $value)
145250TFif (ref $value ne "ARRAY")
14530TFif ($rules->{'error_msg'}) { }
1459100TFif (scalar @{$value;} > $rule_value)
146050TFif ($rules->{'error_msg'}) { }
146850TFunless (defined $value)
1471100TFif (scalar keys %{$value;} > $rule_value)
147250TFif ($rules->{'error_msg'}) { }
148050TFunless (defined $value)
148350TFif (&Scalar::Util::looks_like_number($value)) { }
1484100TFif ($value > $rule_value)
148550TFif ($rules->{'error_msg'}) { }
14940TFif ($rules->{'error_msg'}) { }
1505100TFunless (defined $value)
1509100TFref $rule_value eq 'Regexp' ? :
1510100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
100TFelsif (not $value =~ /$re/) { }
1512100TFif (scalar @matches != scalar @{$value;})
151350TFif ($rules->{'error_msg'}) { }
1520100TFif ($rules->{'error_msg'}) { }
1528100TFif ($@)
1529100TFif ($rules->{'error_msg'}) { }
153750TFunless (defined $value)
1540100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
100TFelsif ($value =~ /$rule_value/) { }
1542100TFif (scalar @matches)
154350TFif ($rules->{'error_msg'}) { }
1550100TFif ($rules->{'error_msg'}) { }
155850TFunless (defined $value)
1561100TFif (ref $rule_value eq 'ARRAY') { }
1563100TFif ($rules->{'type'} eq 'integer' or $rules->{'type'} eq 'number' or $rules->{'type'} eq 'float') { }
1564100TFunless (&List::Util::any(sub {         $_ == $value; } , @{$rule_value;}))
1569100TF!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;}))
1574100TFunless ($ok)
1575100TFif ($rules->{'error_msg'}) { }
158350TFif ($rules->{'error_msg'}) { }
159050TFunless (defined $value)
1593100TFif (ref $rule_value eq 'ARRAY') { }
1595100TFif ($rules->{'type'} eq 'integer' or $rules->{'type'} eq 'number' or $rules->{'type'} eq 'float') { }
1596100TFif (&List::Util::any(sub {         $_ == $value; } , @{$rule_value;}))
1601100TF!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;}))
1606100TFunless ($ok)
1607100TFif ($rules->{'error_msg'}) { }
161550TFif ($rules->{'error_msg'}) { }
162250TFunless (defined $value)
1625100TFif ($rules->{'type'} eq 'object') { }
1626100TFunless ($value->isa($rule_value))
162750TFref $value ? :
163450TFunless (defined $value)
1637100TFif ($rules->{'type'} eq 'object') { }
1638100TFif (ref $rule_value eq 'ARRAY') { }
100TFelsif (not ref $rule_value) { }
1641100TFunless ($value->can($method))
1647100TFunless ($value->can($rule_value))
1658100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
1661100TFif ($custom_type and $custom_type->{'type'})
1665100TFif ($custom_type and $custom_type->{'transform'})
1667100TFif (ref $custom_type->{'transform'} eq 'CODE') { }
1674100TFif ($type eq 'string' or $type eq 'Str') { }
100TFelsif ($type eq 'integer') { }
50TFelsif ($type eq 'number' or $rule_value eq 'float') { }
1675100TFif (ref $member)
167650TFif ($rules->{'error_msg'}) { }
1684100TFif (ref $member or $member =~ /\D/)
1685100TFif ($rules->{'error_msg'}) { }
1693100TFif (ref $member or not $member =~ /^[-+]?(\d*\.\d+|\d+\.?\d*)$/)
169450TFif ($rules->{'error_msg'}) { }
1725100TFif ($rule_value eq 'unix_timestamp') { }
172650TFif ($value < 0 or $value > 2147483647)
1734100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
100TFelsif ($rules->{'type'} eq 'hashref') { }
1735100TFif (ref $value eq 'ARRAY') { }
50TFelsif (defined $value) { }
1745100TFif ($is_field_schema) { }
175250TFunless (validate_strict(\%inner))
176050TFif (ref $rule_value eq 'HASH') { }
1763100TFif (scalar keys %{$nested_with_defaults;})
176450TFif (my $new_args = validate_strict({'input', $nested_with_defaults, 'schema', $rule_value, 'custom_types', $custom_types})) { }
177750TFif (ref $rule_value eq 'CODE') { }
1778100TFif (my $error = &{$rule_value;}($args))
1788100TFunless (defined &$rule_value)
1792100TFunless ($res)
179350TFif ($rules->{'error_msg'}) { }
180150TFif ($rule_value =~ /\D/)
180450TFif ($rule_value < 0)
1812100TFif (scalar @{$rules;}) { }
1819100TFif (ref $rule ne "HASH")
182350TFunless (defined $rule->{'type'})
1832100TFunless ($@)
183550TFif defined $result
1840100TFunless ($rc)
1855100TFif (my $relationships = $params->{'relationships'})
1859100TFif (my $cross_validation = $params->{'cross_validation'})
1862100TFif (not ref $validator or ref $validator ne "CODE")
1866100TFif (my $error = &{$validator;}(\%validated_args, $validator))
1878100TFif ($are_positional_args == 1)
1884100TFif (exists $validated_args{$key})
1887100TFif (defined $rc[$position])
1914100TFunless ref $spec eq "HASH"
1917100TFunless exists $spec->{'name'}
1921100TFif exists $schema{$name}
1933100TFunless defined $value
1935100TFunless ($value =~ /[^[:ascii:]]/)
1939100TFunless utf8::is_utf8($value)
1955100TFif (ref $rules eq "HASH" and exists $rules->{'default'} and not exists $result{$key})
1960100TFif (ref $rules eq "HASH" and $rules->{'schema'} and ref $result{$key} eq "HASH")
197150TFunless ref $relationships eq "ARRAY"
197450TFunless my $type = $rel->{'type'}
1976100TFif ($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') { }
199750TFunless $rel->{'params'}
199850TFunless @params >= 2
2000100TFif exists $args->{$_}
2002100TFif (@present > 1)
201150TFunless $rel->{'params'}
201250TFunless @params >= 2
2014100TFif exists $args->{$_}
2016100TFif (@present == 0)
202650TFunless my $if_param = $rel->{'if'}
202750TFunless my $then_param = $rel->{'then_required'}
2030100TFif (exists $args->{$if_param} and defined $args->{$if_param})
2032100TFif ($args->{$if_param})
2034100TFunless (exists $args->{$then_param} and defined $args->{$then_param})
204550TFunless my $param = $rel->{'param'}
204650TFunless my $requires = $rel->{'requires'}
2049100TFif (exists $args->{$param} and defined $args->{$param})
2050100TFunless (exists $args->{$requires} and defined $args->{$requires})
206050TFunless my $if_param = $rel->{'if'}
206150TFunless my $then_param = $rel->{'then'}
206250TFunless my $operator = $rel->{'operator'}
206450TFunless defined $value
2067100TFif (exists $args->{$if_param} and defined $args->{$if_param} and $args->{$if_param})
206950TFif (exists $args->{$then_param} and defined $args->{$then_param})
2073100TFif ($operator eq '==') { }
100TFelsif ($operator eq '!=') { }
100TFelsif ($operator eq '<') { }
100TFelsif ($operator eq '<=') { }
100TFelsif ($operator eq '>') { }
50TFelsif ($operator eq '>=') { }
2087100TFunless ($valid)
209850TFunless my $if_param = $rel->{'if'}
210050TFunless my $then_param = $rel->{'then_required'}
210150TFunless defined $equals
2104100TFif (exists $args->{$if_param} and defined $args->{$if_param})
2105100TFif ($args->{$if_param} eq $equals)
2107100TFunless (exists $args->{$then_param} and defined $args->{$then_param})
2123100TFif ($logger)
2137100TFif ($logger) { }