Branch Coverage

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

line%coveragebranch
1051100TFref $_[0] eq 'HASH' ? :
1059100TFunless (defined $unknown_parameter_handler)
1060100TFif ($params->{'carp_on_warn'}) { }
1067100TFunless defined $schema
1071100TFif (ref $schema eq "ARRAY")
1076100TFif (ref $schema ne "HASH")
108450TFif ($schema->{'members'} and $schema->{'description'} || $schema->{'error_msg'})
1089100TFif (ref $schema eq "ARRAY")
1094100TFif (exists $params->{'args'} and not defined $args) { }
100TFelsif (ref $args ne 'HASH' and ref $args ne 'ARRAY') { }
1100100TFif (ref $args eq "HASH")
1103100TFunless (exists $schema->{$key})
1104100TFif ($unknown_parameter_handler eq 'die') { }
100TFelsif ($unknown_parameter_handler eq 'warn') { }
100TFelsif ($unknown_parameter_handler eq 'ignore') { }
1110100TFif ($logger)
1124100TFif (defined(my $rules = $schema->{$key})) { }
1125100TFif (ref $rules eq 'HASH') { }
1126100TFunless (defined $rules->{'position'})
112750TFif ($are_positional_args == 1)
1149100TFif ($are_positional_args == 1) { }
115050TFif (ref $args ne "ARRAY")
1158100TFunless (defined $rules)
1164100TFif (ref $rules eq "")
1172100TFif (ref $rules eq "HASH")
1173100TFif (exists $rules->{'description'})
1181100TFif ($is_stringref_type)
1182100TFif (ref $value ne "SCALAR")
1183100TFref $value ? :
1188100TFif ($rules->{'transform'} and defined $value)
1189100TFif (ref $rules->{'transform'} eq 'CODE') { }
1195100TFif (exists $rules->{'optional'}) { }
100TFelsif ($rules->{'nullable'}) { }
100TFelsif (defined $rules->{'type'} and not ref $rules->{'type'} and lc $rules->{'type'} eq 'void') { }
1196100TFif (ref $rules->{'optional'} eq 'CODE') { }
1200100TF$is_stringref_type ? :
1213100TFif (ref $rules eq 'HASH' and $is_optional) { }
100TFelsif (ref $args eq 'HASH' and not exists $args->{$key}) { }
1216100TF$are_positional_args == 1 ? :
1217100TFif ($missing)
1218100TFif ($are_positional_args == 1)
1219100TFif (scalar @{$args;} < $rules->{'position'})
1225100TFif (exists $rules->{'default'})
1231100TFif ($rules->{'schema'}) { }
1233100TFunless scalar %{$value;}
1250100TFif (ref $rules eq "HASH" and ref $rules->{'type'} eq "ARRAY")
1253100TFunless (@type_list)
1261100TFif (ref $rules eq 'HASH') { }
100TFelsif (ref $rules eq 'ARRAY') { }
50TFelsif (ref $rules) { }
1262100TFif (defined(my $min = $rules->{'min'} // $rules->{'minimum'}) and defined(my $max = $rules->{'max'}))
1263100TFif ($min > $max)
1269100TFif ($rules->{'memberof'} or $rules->{'enum'} or $rules->{'values'})
1270100TFif (defined(my $min = $rules->{'min'} // $rules->{'minimum'}))
1273100TFif (defined(my $max = $rules->{'max'}))
1281100TFif (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")
1291100TFif (&Scalar::Util::blessed($rule_value) and $rule_value->can("as_string"))
1295100TFif ($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') { }
100TFelsif ($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') { }
1298100TFif ($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 'scalar') { }
100TFelsif ($type eq 'scalarref') { }
100TFelsif ($type eq 'stringref') { }
100TFelsif ($type eq 'void') { }
100TFelsif ($type eq 'boolean' or $type eq 'bool') { }
100TFelsif ($type eq 'coderef') { }
100TFelsif ($type eq 'object') { }
100TFelsif (my $custom_type = $custom_types->{$type}) { }
1299100TFif (ref $value)
13020TFunless (ref $value eq "" or defined $value and length $value)
1306100TFunless (defined $value)
1309100TFif (not &Scalar::Util::looks_like_number($value) or $value - $value != 0 or $value != int $value)
1314100TFunless (defined $value)
1317100TFunless (&Scalar::Util::looks_like_number($value))
1323100TFunless (defined $value)
1326100TFif (ref $value ne "ARRAY")
1330100TFunless (defined $value)
1333100TFif (ref $value ne "HASH")
1337100TFunless (defined $value)
1340100TFif (ref $value)
1344100TFunless (defined $value)
1347100TFif (ref $value ne "SCALAR")
1348100TFref $value ? :
1352100TFunless (defined $value)
1357100TFif (ref $value)
1361100TFif (scalar keys %{$schema;} != 1)
1364100TFif (defined $value)
1368100TFunless (defined $value)
1371100TFif (defined(my $b = $Readonly::Values::Boolean::booleans{$value})) { }
1377100TFunless (defined $value)
1380100TFif (ref $value ne "CODE")
1384100TFunless (defined $value)
1387100TFunless (&Scalar::Util::blessed($value))
1391100TFif ($custom_type->{'transform'})
1393100TFif (ref $custom_type->{'transform'} eq 'CODE') { }
140450TFunless (defined $rules->{'type'})
1408100TFif (exists $custom_types->{$type}{'min'} or exists $custom_types->{$type}{'minimum'})
1412100TFif ($type eq 'string' or $type eq 'str' or $type eq 'stringref') { }
100TFelsif ($type eq 'arrayref') { }
100TFelsif ($type eq 'hashref') { }
100TFelsif ($type eq 'integer' or $type eq 'number' or $type eq 'float') { }
1413100TFif ($rule_value < 0)
141650TFunless (defined $value)
141950TFif (defined(my $len = _number_of_characters($value))) { }
1420100TFif ($len < $rule_value)
142950TFunless (defined $value)
1432100TFif (scalar @{$value;} < $rule_value)
1433100TF$rule_value > 1 ? :
143750TFunless (defined $value)
1440100TFif (scalar keys %{$value;} < $rule_value)
144550TFunless (defined $value)
144850TFif (&Scalar::Util::looks_like_number($value)) { }
1449100TFif ($value < $rule_value)
1450100TFif ($rules->{'error_msg'}) { }
100TFelsif ($type eq 'integer' and $value == 0) { }
50TFelsif ($type eq 'integer' and $value == 1) { }
147050TFunless (defined $rules->{'type'})
1474100TFif (exists $custom_types->{$type}{'max'})
1478100TFif ($type eq 'string' or $type eq 'str' or $type eq 'stringref') { }
100TFelsif ($type eq 'arrayref') { }
100TFelsif ($type eq 'hashref') { }
100TFelsif ($type eq 'integer' or $type eq 'number' or $type eq 'float') { }
147950TFunless (defined $value)
148250TFif (defined(my $len = _number_of_characters($value))) { }
1483100TFif ($len > $rule_value)
149250TFunless (defined $value)
1495100TFif (scalar @{$value;} > $rule_value)
150050TFunless (defined $value)
1503100TFif (scalar keys %{$value;} > $rule_value)
150850TFunless (defined $value)
151150TFif (&Scalar::Util::looks_like_number($value)) { }
1512100TFif ($value > $rule_value)
151350TFif ($rules->{'error_msg'}) { }
50TFelsif ($type eq 'integer' and $value == 0) { }
50TFelsif ($type eq 'integer' and $value == -1) { }
1533100TFunless (defined $value)
1537100TFref $rule_value eq 'Regexp' ? :
1538100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
100TFelsif (not $value =~ /$re/) { }
1540100TFunless (&all(sub {         $_ =~ /$re/; } , @{$value;}))
1548100TFif ($@)
155350TFunless (defined $value)
155850TFref $rule_value eq 'Regexp' ? :
1560100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
100TFelsif ($value =~ /$re/) { }
1562100TFif (&any(sub {         $_ =~ /$re/; } , @{$value;}))
1571100TFif ($@)
157650TFunless (defined $value)
1579100TFif (ref $rule_value eq 'ARRAY') { }
1580100TFunless (_value_in_list($value, $rule_value, $rules->{'type'} // "", $rules->{'case_sensitive'}))
158850TFunless (defined $value)
1591100TFif (ref $rule_value eq 'ARRAY') { }
1592100TFif (_value_in_list($value, $rule_value, $rules->{'type'} // "", $rules->{'case_sensitive'}))
160050TFunless (defined $value)
1603100TFif ($rules->{'type'} eq 'object') { }
1604100TFunless ($value->isa($rule_value))
160550TFref $value ? :
161250TFunless (defined $value)
1615100TFif ($rules->{'type'} eq 'object') { }
1616100TFif (ref $rule_value eq 'ARRAY') { }
100TFelsif (not ref $rule_value) { }
1619100TFunless ($value->can($method))
1625100TFunless ($value->can($rule_value))
1636100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
163950TFif ($custom_type and $custom_type->{'type'})
1643100TFif ($custom_type and $custom_type->{'transform'})
1645100TFif (ref $custom_type->{'transform'} eq 'CODE') { }
1651100TFif ($type eq 'string' or $type eq 'Str') { }
100TFelsif ($type eq 'integer') { }
100TFelsif ($type eq 'number' or $rule_value eq 'float') { }
50TFelsif ($type eq 'object') { }
1652100TFif (ref $member)
1657100TFif (ref $member or $member =~ /\D/)
1662100TFif (ref $member or not $member =~ /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)$/)
16670TFunless (&Scalar::Util::blessed($member))
1695100TFif ($rule_value eq 'unix_timestamp') { }
1696100TFif ($value < 0 or $value > 2147483647)
1704100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
100TFelsif ($rules->{'type'} eq 'hashref') { }
170550TFif (ref $value eq 'ARRAY') { }
0TFelsif (defined $value) { }
1715100TFif ($is_field_schema) { }
172250TFunless (validate_strict(\%inner))
173050TFif (ref $rule_value eq 'HASH') { }
1733100TFif (scalar keys %{$nested_with_defaults;})
173450TFif (my $new_args = validate_strict({'input', $nested_with_defaults, 'schema', $rule_value, 'custom_types', $custom_types})) { }
1747100TFif (ref $rule_value eq 'CODE') { }
1748100TFif (my $error = &{$rule_value;}($args))
1758100TFunless (defined &$rule_value)
1762100TFunless ($res)
176750TFif ($rule_value < 0)
1770100TFif ($rule_value =~ /\D/)
1778100TFif (scalar @{$rules;}) { }
1785100TFif (ref $rule ne "HASH")
178850TFunless (defined $rule->{'type'})
1796100TFunless ($@)
179950TFif defined $result
1804100TFunless ($rc)
1819100TFif (my $relationships = $params->{'relationships'})
1823100TFif (my $cross_validation = $params->{'cross_validation'})
1826100TFif (not ref $validator or ref $validator ne "CODE")
1830100TFif (my $error = &{$validator;}(\%validated_args, $validator))
1842100TFif ($are_positional_args == 1)
1848100TFif (exists $validated_args{$key})
1851100TFif (defined $rc[$position])
1878100TFunless ref $spec eq "HASH"
1881100TFunless exists $spec->{'name'}
1885100TFif exists $schema{$name}
1897100TFunless defined $value
1899100TFunless ($value =~ /[^[:ascii:]]/)
1903100TFunless utf8::is_utf8($value)
1919100TFif (ref $rules eq "HASH" and exists $rules->{'default'} and not exists $result{$key})
1924100TFif (ref $rules eq "HASH" and $rules->{'schema'} and ref $result{$key} eq "HASH")
193550TFunless ref $relationships eq "ARRAY"
193850TFunless my $type = $rel->{'type'}
1940100TFif ($type eq 'mutually_exclusive') { }
100TFelsif ($type eq 'required_group') { }
100TFelsif ($type eq 'conditional_requirement') { }
100TFelsif ($type eq 'dependency') { }
100TFelsif ($type eq 'value_constraint') { }
100TFelsif ($type eq 'value_conditional') { }
196150TFunless $rel->{'params'}
196250TFunless @params >= 2
1966100TFif (@present > 1)
197550TFunless $rel->{'params'}
1976100TFunless @params >= 2
1980100TFif (@present == 0)
1990100TFunless my $if_param = $rel->{'if'}
1991100TFunless my $then_param = $rel->{'then_required'}
1994100TFif (_param_defined($args, $if_param))
1996100TFif ($args->{$if_param})
1998100TFunless (_param_defined($args, $then_param))
2009100TFunless my $param = $rel->{'param'}
201050TFunless my $requires = $rel->{'requires'}
2013100TFif (_param_defined($args, $param))
2014100TFunless (_param_defined($args, $requires))
202450TFunless my $if_param = $rel->{'if'}
202550TFunless my $then_param = $rel->{'then'}
202650TFunless my $operator = $rel->{'operator'}
202850TFunless defined $value
2031100TFif (_param_defined($args, $if_param) and $args->{$if_param})
203350TFif (_param_defined($args, $then_param))
2037100TFif ($operator eq '==') { }
100TFelsif ($operator eq '!=') { }
100TFelsif ($operator eq '<') { }
100TFelsif ($operator eq '<=') { }
100TFelsif ($operator eq '>') { }
100TFelsif ($operator eq '>=') { }
2051100TFunless ($valid)
206250TFunless my $if_param = $rel->{'if'}
206450TFunless my $then_param = $rel->{'then_required'}
206550TFunless defined $equals
2068100TFif (_param_defined($args, $if_param))
2069100TFif ($args->{$if_param} eq $equals)
2071100TFunless (_param_defined($args, $then_param))
2108100TF$is_icase ? :
100TF$is_numeric ? :
211350TFif (defined $entry and not defined $entry->[0])
2118100TFunless (defined $entry)
2120100TFif ($is_numeric) { }
100TFelsif ($is_icase) { }
2138100TF$is_icase ? :
100TF$is_numeric ? :
2158100TFif ($logger)
2172100TFif ($logger) { }