Branch Coverage

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

line%coveragebranch
764100TFif (ref $schema ne "HASH")
77250TFif ($schema->{'members'} and $schema->{'description'} || $schema->{'error_msg'})
778100TFif (exists $params->{'args'} and not defined $args) { }
100TFelsif (ref $args ne 'HASH' and ref $args ne 'ARRAY') { }
784100TFif (ref $args eq "HASH")
787100TFunless (exists $schema->{$key})
788100TFif ($unknown_parameter_handler eq 'die') { }
100TFelsif ($unknown_parameter_handler eq 'warn') { }
100TFelsif ($unknown_parameter_handler eq 'ignore') { }
794100TFif ($logger)
808100TFif (defined(my $rules = $schema->{$key})) { }
809100TFif (ref $rules eq 'HASH') { }
810100TFunless (defined $rules->{'position'})
81150TFif ($are_positional_args == 1)
832100TF$are_positional_args == 1 ? :
834100TFunless (defined $rules)
840100TFif (ref $rules eq "")
848100TFif (ref $rules eq "HASH")
84950TFif (exists $rules->{'description'})
852100TFif ($rules->{'transform'} and defined $value)
853100TFif (ref $rules->{'transform'} eq 'CODE') { }
859100TFif (exists $rules->{'optional'})
860100TFif (ref $rules->{'optional'} eq 'CODE') { }
869100TFif (ref $rules eq 'HASH' and $is_optional) { }
100TFelsif (ref $args eq 'HASH' and not exists $args->{$key}) { }
871100TFif ($are_positional_args == 1) { }
872100TFunless (defined @{$args;}[$rules->{'position'}])
876100TFunless (exists $args->{$key})
880100TFif ($look_for_default)
881100TFif ($are_positional_args == 1)
88250TFif (scalar @{$args;} < $rules->{'position'})
888100TFif (exists $rules->{'default'})
893100TFif ($rules->{'schema'}) { }
895100TFunless scalar %{$value;}
907100TFif (ref $rules eq 'HASH') { }
100TFelsif (ref $rules eq 'ARRAY') { }
50TFelsif (ref $rules) { }
908100TFif (my $min = $rules->{'min'} and my $max = $rules->{'max'})
909100TFif ($min > $max)
914100TFif ($rules->{'memberof'})
915100TFif (my $min = $rules->{'min'})
918100TFif (my $max = $rules->{'max'})
926100TFif (ref $rule_value eq "CODE" and $rule_name ne "validate" and $rule_name ne "callback" and $rule_name ne "validator")
930100TFif ($rule_name eq 'type') { }
100TFelsif ($rule_name eq 'min') { }
100TFelsif ($rule_name eq 'max') { }
100TFelsif ($rule_name eq 'matches') { }
100TFelsif ($rule_name eq 'nomatch') { }
100TFelsif ($rule_name eq 'memberof') { }
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') { }
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') { }
933100TFif ($type eq 'string') { }
100TFelsif ($type eq 'integer') { }
100TFelsif ($type eq 'number' or $type eq 'float') { }
100TFelsif ($type eq 'arrayref') { }
100TFelsif ($type eq 'hashref') { }
100TFelsif ($type eq 'boolean') { }
100TFelsif ($type eq 'coderef') { }
100TFelsif ($type eq 'object') { }
100TFelsif (my $custom_type = $custom_types->{$type}) { }
934100TFif (ref $value)
9370TFunless (ref $value eq "" or defined $value and length $value)
941100TFunless (defined $value)
944100TFunless ($value =~ /^\s*[+\-]?\d+\s*$/)
945100TFif ($rules->{'error_msg'}) { }
953100TFunless (defined $value)
956100TFunless (&Scalar::Util::looks_like_number($value))
95750TFif ($rules->{'error_msg'}) { }
966100TFunless (defined $value)
96950TFif (ref $value ne "ARRAY")
9700TFif ($rules->{'error_msg'}) { }
977100TFunless (defined $value)
98050TFif (ref $value ne "HASH")
9810TFif ($rules->{'error_msg'}) { }
988100TFunless (defined $value)
991100TFif ($value eq 'true' or $value eq 'on' or $value eq 'yes') { }
100TFelsif ($value eq 'false' or $value eq 'off' or $value eq 'no') { }
996100TFif ($value ne 1 and $value ne 0)
99750TFif ($rules->{'error_msg'}) { }
1005100TFunless (defined $value)
100850TFif (ref $value ne "CODE")
10090TFif ($rules->{'error_msg'}) { }
1016100TFunless (defined $value)
1019100TFunless (&Scalar::Util::blessed($value))
102050TFif ($rules->{'error_msg'}) { }
1027100TFif ($custom_type->{'transform'})
102950TFif (ref $custom_type->{'transform'} eq 'CODE') { }
104150TFunless (defined $rules->{'type'})
1045100TFif (exists $custom_types->{$type}{'min'})
1049100TFif ($type eq 'string') { }
100TFelsif ($rules->{'type'} eq 'arrayref') { }
100TFelsif ($rules->{'type'} eq 'hashref') { }
100TFelsif ($type eq 'integer' or $type eq 'number' or $type eq 'float') { }
1050100TFif ($rule_value < 0)
105150TFif ($rules->{'error_msg'}) { }
105750TFunless (defined $value)
106150TFunless utf8::is_utf8($value)
106350TFunless (defined $len)
1068100TFif ($len < $rule_value)
107350TFunless (defined $value)
1076100TFif (ref $value ne "ARRAY")
107750TFif ($rules->{'error_msg'}) { }
1083100TFif (scalar @{$value;} < $rule_value)
108450TFif ($rules->{'error_msg'}) { }
109250TFunless (defined $value)
1095100TFif (scalar keys %{$value;} < $rule_value)
109650TFif ($rules->{'error_msg'}) { }
110450TFunless (defined $value)
1107100TFif (&Scalar::Util::looks_like_number($value)) { }
1108100TFif ($value < $rule_value)
1109100TFif ($rules->{'error_msg'}) { }
111850TFif ($rules->{'error_msg'}) { }
112950TFunless (defined $rules->{'type'})
1133100TFif (exists $custom_types->{$type}{'max'})
1137100TFif ($type eq 'string') { }
100TFelsif ($rules->{'type'} eq 'arrayref') { }
100TFelsif ($rules->{'type'} eq 'hashref') { }
100TFelsif ($type eq 'integer' or $type eq 'number' or $type eq 'float') { }
113850TFunless (defined $value)
114250TFunless utf8::is_utf8($value)
114450TFunless (defined $len)
1149100TFif ($len > $rule_value)
115450TFunless (defined $value)
115750TFif (ref $value ne "ARRAY")
11580TFif ($rules->{'error_msg'}) { }
1164100TFif (scalar @{$value;} > $rule_value)
116550TFif ($rules->{'error_msg'}) { }
117350TFunless (defined $value)
1176100TFif (scalar keys %{$value;} > $rule_value)
117750TFif ($rules->{'error_msg'}) { }
118550TFunless (defined $value)
118850TFif (&Scalar::Util::looks_like_number($value)) { }
1189100TFif ($value > $rule_value)
119050TFif ($rules->{'error_msg'}) { }
11990TFif ($rules->{'error_msg'}) { }
1210100TFunless (defined $value)
1214100TFref $rule_value eq 'Regexp' ? :
1215100TFif ($rules->{'type'} eq 'arrayref') { }
100TFelsif (not $value =~ /$re/) { }
121750TFif (scalar @matches != scalar @{$value;})
12180TFif ($rules->{'error_msg'}) { }
1225100TFif ($rules->{'error_msg'}) { }
1233100TFif ($@)
1234100TFif ($rules->{'error_msg'}) { }
124250TFunless (defined $value)
1245100TFif ($rules->{'type'} eq 'arrayref') { }
100TFelsif ($value =~ /$rule_value/) { }
1247100TFif (scalar @matches)
124850TFif ($rules->{'error_msg'}) { }
125550TFif ($rules->{'error_msg'}) { }
126350TFunless (defined $value)
1266100TFif (ref $rule_value eq 'ARRAY') { }
1268100TFif ($rules->{'type'} eq 'integer' or $rules->{'type'} eq 'number' or $rules->{'type'} eq 'float') { }
1269100TFunless (&List::Util::any(sub {         $_ == $value; } , @{$rule_value;}))
1274100TF!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;}))
1279100TFunless ($ok)
1280100TFif ($rules->{'error_msg'}) { }
128850TFif ($rules->{'error_msg'}) { }
129550TFunless (defined $value)
1298100TFif (ref $rule_value eq 'ARRAY') { }
1300100TFif ($rules->{'type'} eq 'integer' or $rules->{'type'} eq 'number' or $rules->{'type'} eq 'float') { }
1301100TFif (&List::Util::any(sub {         $_ == $value; } , @{$rule_value;}))
130650TF!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;}))
1311100TFunless ($ok)
1312100TFif ($rules->{'error_msg'}) { }
132050TFif ($rules->{'error_msg'}) { }
1327100TFif ($rules->{'type'} eq 'object') { }
1328100TFunless ($value->isa($rule_value))
133650TFunless (defined $value)
1339100TFif ($rules->{'type'} eq 'object') { }
1340100TFif (ref $rule_value eq 'ARRAY') { }
100TFelsif (not ref $rule_value) { }
1343100TFunless ($value->can($method))
1349100TFunless ($value->can($rule_value))
136050TFif ($rules->{'type'} eq 'arrayref') { }
1363100TFif ($custom_type and $custom_type->{'type'})
1367100TFif ($custom_type and $custom_type->{'transform'})
136950TFif (ref $custom_type->{'transform'} eq 'CODE') { }
1376100TFif ($type eq 'string') { }
100TFelsif ($type eq 'integer') { }
50TFelsif ($type eq 'number' or $rule_value eq 'float') { }
137750TFif (ref $member)
13780TFif ($rules->{'error_msg'}) { }
1386100TFif (ref $member or $member =~ /\D/)
1387100TFif ($rules->{'error_msg'}) { }
1395100TFif (ref $member or not $member =~ /^[-+]?(\d*\.\d+|\d+\.?\d*)$/)
139650TFif ($rules->{'error_msg'}) { }
1424100TFif ($rules->{'type'} eq 'arrayref') { }
50TFelsif ($rules->{'type'} eq 'hashref') { }
142550TFif (ref $value eq 'ARRAY') { }
0TFelsif (defined $value) { }
142750TFunless (validate_strict({"input", {$key, $member}, "schema", {$key, $rule_value}, "custom_types", $custom_types}))
143550TFif (ref $value eq 'HASH') { }
1438100TFif (scalar keys %{$value;})
143950TFif (my $new_args = validate_strict({'input', $nested_with_defaults, 'schema', $rule_value, 'custom_types', $custom_types})) { }
145250TFif (ref $rule_value eq 'CODE') { }
1453100TFif (my $error = &{$rule_value;}($args))
1462100TFunless (defined &$rule_value)
1466100TFunless ($res)
146750TFif ($rules->{'error_msg'}) { }
147550TFif ($rule_value =~ /\D/)
147850TFif ($rule_value < 0)
1486100TFif (scalar @{$rules;}) { }
1491100TFif (ref $rule ne "HASH")
149550TFunless (defined $rule->{'type'})
1503100TFunless ($@)
1508100TFunless ($rc)
1522100TFif (my $cross_validation = $params->{'cross_validation'})
1525100TFif (not ref $validator or ref $validator ne "CODE")
1529100TFif (my $error = &{$validator;}(\%validated_args, $validator))
1541100TFif ($are_positional_args == 1)
154450TFif (my $value = delete $validated_args{$key})
154650TFif (defined $rc[$position])
1564100TFif ($logger) { }
1579100TFif ($logger) { }
1593100TFif (ref $rules eq "HASH" and exists $rules->{'default'} and not exists $result{$key})
1598100TFif (ref $rules eq "HASH" and $rules->{'schema'} and ref $result{$key} eq "HASH")