Branch Coverage

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

line%coveragebranch
1212100TFif $_depth > 20
1215100TFref $_[0] eq 'HASH' ? :
1223100TFunless (defined $unknown_parameter_handler)
1224100TFif ($params->{'carp_on_warn'}) { }
1231100TFunless defined $schema
1235100TFif (ref $schema eq "ARRAY")
1240100TFif (ref $schema ne "HASH")
124850TFif ($schema->{'members'} and $schema->{'description'} || $schema->{'error_msg'})
1253100TFif (ref $schema eq "ARRAY")
1258100TFif (exists $params->{'args'} and not defined $args) { }
100TFelsif (ref $args ne 'HASH' and ref $args ne 'ARRAY') { }
1264100TFif (ref $args eq "HASH")
1270100TFif (ref $r eq "HASH" and ref $r->{'aliases'} eq "ARRAY")
1276100TFunless (exists $schema->{$key} or exists $_alias_to_canonical{$key})
1277100TFif ($unknown_parameter_handler eq 'die') { }
100TFelsif ($unknown_parameter_handler eq 'warn') { }
100TFelsif ($unknown_parameter_handler eq 'ignore') { }
1283100TFif ($logger)
1297100TFif (defined(my $rules = $schema->{$key})) { }
1298100TFif (ref $rules eq 'HASH') { }
129950TFif ($rules->{'slurp'} and not defined $rules->{'position'})
1302100TFunless (defined $rules->{'position'})
130350TFif ($are_positional_args == 1)
1328100TFif ($are_positional_args != 1 and ref $rules eq "HASH" and ref $rules->{'aliases'} eq "ARRAY" and not exists $args->{$key})
1332100TFif (exists $args->{$alias})
1340100TFif ($are_positional_args == 1) { }
134150TFif (ref $args ne "ARRAY")
1344100TFif (ref $rules eq 'HASH' and $rules->{'slurp'}) { }
1354100TFunless (defined $rules)
1360100TFif (ref $rules eq "")
1369100TFif (ref $rules eq "HASH")
1370100TFif (exists $rules->{'description'})
1378100TFif ($is_stringref_type)
1379100TFif (ref $value ne "SCALAR")
1380100TFref $value ? :
1385100TFif ($rules->{'transform'} and defined $value)
1386100TFif (ref $rules->{'transform'} eq 'CODE') { }
1392100TFif (exists $rules->{'optional'}) { }
100TFelsif ($rules->{'nullable'}) { }
100TFelsif (defined $rules->{'type'} and not ref $rules->{'type'} and lc $rules->{'type'} eq 'void') { }
100TFelsif ($rules->{'slurp'}) { }
1393100TFif (ref $rules->{'optional'} eq 'CODE') { }
1397100TF$is_stringref_type ? :
1412100TFif (ref $rules eq 'HASH' and $is_optional) { }
100TFelsif (ref $args eq 'HASH' and not exists $args->{$lookup_key}) { }
1414100TFif ($are_positional_args == 1) { }
1416100TF$rules->{'slurp'} ? :
1420100TFif ($missing)
1421100TFif ($are_positional_args == 1)
1422100TFif (scalar @{$args;} < $rules->{'position'})
1428100TFif (exists $rules->{'default'})
1434100TFif ($rules->{'schema'}) { }
1436100TFunless scalar %{$value;}
1454100TFif (ref $rules eq "HASH" and not ref $rules->{'type'} and defined $rules->{'type'} and $rules->{'type'} =~ /\|/)
1457100TFif (ref $rules eq "HASH" and ref $rules->{'type'} eq "ARRAY")
1460100TFunless (@type_list)
1468100TFif (ref $rules eq 'HASH') { }
100TFelsif (ref $rules eq 'ARRAY') { }
50TFelsif (ref $rules) { }
1469100TFif (defined(my $min = $rules->{'min'} // $rules->{'minimum'}) and defined(my $max = $rules->{'max'}))
1470100TFif ($min > $max)
1476100TFif ($rules->{'memberof'} or $rules->{'enum'} or $rules->{'values'})
1477100TFif (defined(my $min = $rules->{'min'} // $rules->{'minimum'}))
1480100TFif (defined(my $max = $rules->{'max'}))
1488100TFif (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")
1498100TFif (&Scalar::Util::blessed($rule_value) and $rule_value->can("as_string"))
1502100TFif ($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 'bnf') { }
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 'does') { }
100TFelsif ($rule_name eq 'classisa') { }
100TFelsif ($rule_name eq 'subclass') { }
100TFelsif ($rule_name eq 'classdoes') { }
100TFelsif ($rule_name eq 'driver') { }
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') { }
100TFelsif ($rule_name eq 'slurp') { }
100TFelsif ($rule_name eq 'aliases') { }
1505100TFif ($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 'regex') { }
100TFelsif ($type eq 'handle') { }
100TFelsif ($type eq 'arraylike') { }
100TFelsif ($type eq 'hashlike') { }
100TFelsif ($type eq 'codelike') { }
100TFelsif ($type eq 'invocant') { }
100TFelsif ($type eq 'object') { }
100TFelsif (my $custom_type = $custom_types->{$type}) { }
1506100TFif (ref $value)
15090TFunless (ref $value eq "" or defined $value and length $value)
1513100TFunless (defined $value)
1516100TFif (not &Scalar::Util::looks_like_number($value) or $value - $value != 0 or $value != int $value)
1521100TFunless (defined $value)
1524100TFunless (&Scalar::Util::looks_like_number($value))
1530100TFunless (defined $value)
1533100TFif (ref $value ne "ARRAY")
1537100TFunless (defined $value)
1540100TFif (ref $value ne "HASH")
1544100TFunless (defined $value)
1547100TFif (ref $value)
1551100TFunless (defined $value)
1554100TFif (ref $value ne "SCALAR")
1555100TFref $value ? :
1559100TFunless (defined $value)
1564100TFif (ref $value)
1568100TFif (scalar keys %{$schema;} != 1)
1571100TFif (defined $value)
1575100TFunless (defined $value)
1578100TFif (defined(my $b = $Readonly::Values::Boolean::booleans{$value})) { }
1584100TFunless (defined $value)
1587100TFif (ref $value ne "CODE")
1591100TFunless (defined $value)
1594100TFif (ref $value ne "Regexp")
159550TFref $value ? :
1599100TFunless (defined $value)
1603100TFif (ref $value eq 'GLOB' and defined fileno $value) { }
50TFelsif (&Scalar::Util::blessed($value) and $value->isa('IO::Handle')) { }
1610100TFunless ($is_handle)
161450TFunless (defined $value)
161750TFunless (ref $value eq "ARRAY" or &Scalar::Util::blessed($value) and overload::Method($value, "\@{}"))
162150TFunless (defined $value)
162450TFunless (ref $value eq "HASH" or &Scalar::Util::blessed($value) and overload::Method($value, "%{}"))
162850TFunless (defined $value)
163150TFunless (ref $value eq "CODE" or &Scalar::Util::blessed($value) and overload::Method($value, "&{}"))
163550TFunless (defined $value)
1638100TFunless (&Scalar::Util::blessed($value) or not ref $value and $value =~ /\A[A-Za-z_]\w*(?:::[A-Za-z_]\w*)*\z/)
1642100TFunless (defined $value)
1645100TFunless (&Scalar::Util::blessed($value))
1649100TFif ($custom_type->{'transform'})
1651100TFif (ref $custom_type->{'transform'} eq 'CODE') { }
166250TFunless (defined $rules->{'type'})
1666100TFif (exists $custom_types->{$type}{'min'} or exists $custom_types->{$type}{'minimum'})
1670100TFif ($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') { }
1671100TFif ($rule_value < 0)
1674100TFunless (defined $value)
1675100TFif ($rule_value > 0 and not $is_optional)
167650TF$rule_value == 1 ? :
168150TFif (defined(my $len = _number_of_characters($value))) { }
1682100TFif ($len < $rule_value)
1691100TFunless (defined $value)
169250TFif ($rule_value > 0 and not $is_optional)
169350TF$rule_value > 1 ? :
1698100TFif (scalar @{$value;} < $rule_value)
1699100TF$rule_value > 1 ? :
1703100TFunless (defined $value)
170450TFif ($rule_value > 0 and not $is_optional)
1710100TFif (scalar keys %{$value;} < $rule_value)
1715100TFunless (defined $value)
171650TFif ($rule_value > 0 and not $is_optional)
172250TFif (&Scalar::Util::looks_like_number($value)) { }
1723100TFif ($value < $rule_value)
1724100TFif ($rules->{'error_msg'}) { }
100TFelsif ($type eq 'integer' and $value == 0) { }
50TFelsif ($type eq 'integer' and $value == 1) { }
174450TFunless (defined $rules->{'type'})
1748100TFif (exists $custom_types->{$type}{'max'})
1752100TFif ($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') { }
175350TFunless (defined $value)
175650TFif (defined(my $len = _number_of_characters($value))) { }
1757100TFif ($len > $rule_value)
176650TFunless (defined $value)
1769100TFif (scalar @{$value;} > $rule_value)
177450TFunless (defined $value)
1777100TFif (scalar keys %{$value;} > $rule_value)
178250TFunless (defined $value)
178550TFif (&Scalar::Util::looks_like_number($value)) { }
1786100TFif ($value > $rule_value)
178750TFif ($rules->{'error_msg'}) { }
50TFelsif ($type eq 'integer' and $value == 0) { }
50TFelsif ($type eq 'integer' and $value == -1) { }
1807100TFunless (defined $value)
1811100TFref $rule_value eq 'Regexp' ? :
1812100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
100TFelsif (not $value =~ /$re/) { }
1814100TFunless (&all(sub {         $_ =~ /$re/; } , @{$value;}))
1822100TFif ($@)
182750TFunless (defined $value)
183250TFref $rule_value eq 'Regexp' ? :
1834100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
100TFelsif ($value =~ /$re/) { }
1836100TFif (&any(sub {         $_ =~ /$re/; } , @{$value;}))
1845100TFif ($@)
1850100TFunless (defined $value)
1853100TFif (ref $rule_value ne "ARRAY")
1858100TFunless (&$matcher($value))
186350TFunless (defined $value)
1866100TFif (ref $rule_value eq 'ARRAY') { }
1867100TFunless (_value_in_list($value, $rule_value, $rules->{'type'} // "", $rules->{'case_sensitive'}))
187550TFunless (defined $value)
1878100TFif (ref $rule_value eq 'ARRAY') { }
1879100TFif (_value_in_list($value, $rule_value, $rules->{'type'} // "", $rules->{'case_sensitive'}))
188750TFunless (defined $value)
1890100TFif ($rules->{'type'} eq 'object') { }
1891100TFunless ($value->isa($rule_value))
189250TFref $value ? :
189950TFunless (defined $value)
1902100TFif ($rules->{'type'} eq 'object') { }
1903100TFif (ref $rule_value eq 'ARRAY') { }
100TFelsif (not ref $rule_value) { }
1906100TFunless ($value->can($method))
1912100TFunless ($value->can($rule_value))
192350TFunless (defined $value)
1926100TFif ($rules->{'type'} eq 'object') { }
1927100TFunless (&Scalar::Util::blessed($value) and $value->DOES($rule_value))
1935100TFunless (defined $value)
1938100TFunless (not ref $value and $value =~ /\A[A-Za-z_]\w*(?:::[A-Za-z_]\w*)*\z/ and $value->isa($rule_value))
194350TFunless (defined $value)
1946100TFunless (not ref $value and $value =~ /\A[A-Za-z_]\w*(?:::[A-Za-z_]\w*)*\z/ and $value ne $rule_value and $value->isa($rule_value))
195250TFunless (defined $value)
1955100TFunless (not ref $value and $value =~ /\A[A-Za-z_]\w*(?:::[A-Za-z_]\w*)*\z/ and $value->DOES($rule_value))
196050TFunless (defined $value)
1963100TFunless (not ref $value and $value =~ /\A[A-Za-z_]\w*(?:::[A-Za-z_]\w*)*\z/)
197150TFif ($@)
1976100TFunless ($value->isa($rule_value))
1981100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
198450TFif ($custom_type and $custom_type->{'type'})
1988100TFif ($custom_type and $custom_type->{'transform'})
1990100TFif (ref $custom_type->{'transform'} eq 'CODE') { }
1996100TFif ($type eq 'string' or $type eq 'Str') { }
100TFelsif ($type eq 'integer') { }
100TFelsif ($type eq 'number' or $rule_value eq 'float') { }
50TFelsif ($type eq 'object') { }
1997100TFif (ref $member)
2002100TFif (ref $member or $member =~ /\D/)
2007100TFif (ref $member or not $member =~ /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)$/)
20120TFunless (&Scalar::Util::blessed($member))
2040100TFif ($rule_value eq 'unix_timestamp') { }
100TFelsif ($rule_value eq 'identifier') { }
100TFelsif ($rule_value eq 'class_name') { }
2041100TFif ($value < 0 or $value > 2147483647)
2045100TFif (defined $value and not $value =~ /\A[A-Za-z_]\w*\z/)
2049100TFif (defined $value and not $value =~ /\A[A-Za-z_]\w*(?:::[A-Za-z_]\w*)*\z/)
2057100TFif ($rules->{'type'} eq 'arrayref' or $rules->{'type'} eq 'ArrayRef') { }
100TFelsif ($rules->{'type'} eq 'hashref') { }
205850TFif (ref $value eq 'ARRAY') { }
0TFelsif (defined $value) { }
2068100TFif ($is_field_schema) { }
207550TFunless (validate_strict(\%inner))
208350TFif (ref $rule_value eq 'HASH') { }
2086100TFif (scalar keys %{$nested_with_defaults;})
208750TFif (my $new_args = validate_strict({'input', $nested_with_defaults, 'schema', $rule_value, 'custom_types', $custom_types})) { }
2100100TFif (ref $rule_value eq 'CODE') { }
2101100TFif (my $error = &{$rule_value;}($args))
2111100TFunless (defined &$rule_value)
2115100TFunless ($res)
212050TFif ($rule_value < 0)
2123100TFif ($rule_value =~ /\D/)
212750TFif ($rule_value and $are_positional_args != 1)
2138100TFif (scalar @{$rules;}) { }
2145100TFif (ref $rule ne "HASH")
214850TFunless (defined $rule->{'type'})
2156100TFunless ($@)
215950TFif defined $result
2164100TFunless ($rc)
2179100TFif (my $relationships = $params->{'relationships'})
2183100TFif (my $cross_validation = $params->{'cross_validation'})
2186100TFif (not ref $validator or ref $validator ne "CODE")
2190100TFif (my $error = &{$validator;}(\%validated_args, $validator))
2202100TFif ($are_positional_args == 1)
2208100TFif (exists $validated_args{$key})
2211100TFif (defined $rc[$position])
2270100TFunless (ref $schema eq "HASH" or ref $schema eq "ARRAY")
2295100TFunless ref $spec eq "HASH"
2298100TFunless exists $spec->{'name'}
2302100TFif exists $schema{$name}
2314100TFunless defined $value
2316100TFunless ($value =~ /[^[:ascii:]]/)
2320100TFunless utf8::is_utf8($value)
2336100TFif (ref $rules eq "HASH" and exists $rules->{'default'} and not exists $result{$key})
2341100TFif (ref $rules eq "HASH" and $rules->{'schema'} and ref $result{$key} eq "HASH")
235250TFunless ref $relationships eq "ARRAY"
235550TFunless my $type = $rel->{'type'}
2357100TFif ($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') { }
237850TFunless $rel->{'params'}
237950TFunless @params >= 2
2383100TFif (@present > 1)
239250TFunless $rel->{'params'}
2393100TFunless @params >= 2
2397100TFif (@present == 0)
2407100TFunless my $if_param = $rel->{'if'}
2408100TFunless my $then_param = $rel->{'then_required'}
2411100TFif (_param_defined($args, $if_param))
2413100TFif ($args->{$if_param})
2415100TFunless (_param_defined($args, $then_param))
2426100TFunless my $param = $rel->{'param'}
242750TFunless my $requires = $rel->{'requires'}
2430100TFif (_param_defined($args, $param))
2431100TFunless (_param_defined($args, $requires))
244150TFunless my $if_param = $rel->{'if'}
244250TFunless my $then_param = $rel->{'then'}
244350TFunless my $operator = $rel->{'operator'}
244550TFunless defined $value
2448100TFif (_param_defined($args, $if_param) and $args->{$if_param})
245050TFif (_param_defined($args, $then_param))
2454100TFif ($operator eq '==') { }
100TFelsif ($operator eq '!=') { }
100TFelsif ($operator eq '<') { }
100TFelsif ($operator eq '<=') { }
100TFelsif ($operator eq '>') { }
100TFelsif ($operator eq '>=') { }
2468100TFunless ($valid)
247950TFunless my $if_param = $rel->{'if'}
248150TFunless my $then_param = $rel->{'then_required'}
248250TFunless defined $equals
2485100TFif (_param_defined($args, $if_param))
2486100TFif ($args->{$if_param} eq $equals)
2488100TFunless (_param_defined($args, $then_param))
2525100TF$is_icase ? :
100TF$is_numeric ? :
253050TFif (defined $entry and not defined $entry->[0])
2535100TFunless (defined $entry)
2537100TFif ($is_numeric) { }
100TFelsif ($is_icase) { }
2555100TF$is_icase ? :
100TF$is_numeric ? :
2575100TFif ($logger)
2589100TFif ($logger) { }