# Certain tests have been shown to be problematical for a few locales. Don't
# fail them unless at least this percentage of the tested locales fail.
-# Some Windows machines are defective in every locale but the C, calling \t
-# printable; superscripts to be digits, etc. See
-# http://markmail.org/message/5jwam4xsx4amsdnv. Also on AIX machines, many
-# locales call a no-break space a graphic.
+# On AIX machines, many locales call a no-break space a graphic.
# (There aren't 1000 locales currently in existence, so 99.9 works)
-my $acceptable_fold_failure_percentage = ($^O =~ / ^ ( MSWin32 | AIX ) $ /ix)
- ? 99.9
- : 5;
+my $acceptable_failure_percentage = ($^O =~ / ^ ( AIX ) $ /ix)
+ ? 99.9
+ : 5;
# The list of test numbers of the problematic tests.
-my @problematical_tests;
+my %problematical_tests;
use Dumpvalue;
);
sub debug {
return unless $debug;
- my($mess) = join "", @_;
+ my($mess) = join "", '# ', @_;
chop $mess;
print $dumper->stringify($mess,1), "\n";
}
printf @_ if $debug;
}
-$a = 'abc %';
+$a = 'abc %9';
my $test_num = 0;
sub check_taint ($;$) {
my $message_tail = $_[1] // "";
- $message_tail = ": $message_tail" if $message_tail;
+
+ # Extra blanks are so aligns with taint_not output
+ $message_tail = ": $message_tail" if $message_tail;
ok is_tainted($_[0]), "verify that is tainted$message_tail";
}
sub check_taint_not ($;$) {
my $message_tail = $_[1] // "";
- $message_tail = ": $message_tail" if $message_tail;
+ $message_tail = ": $message_tail" if $message_tail;
ok((not is_tainted($_[0])), "verify that isn't tainted$message_tail");
}
use locale; # engage locale and therefore locale taint.
-check_taint_not $a, "\t\$a";
-
-check_taint uc($a);
-check_taint "\U$a";
-check_taint ucfirst($a);
-check_taint "\u$a";
-check_taint lc($a);
-check_taint fc($a);
-check_taint "\L$a";
-check_taint "\F$a";
-check_taint lcfirst($a);
-check_taint "\l$a";
-
-check_taint_not sprintf('%e', 123.456);
-check_taint_not sprintf('%f', 123.456);
-check_taint_not sprintf('%g', 123.456);
-check_taint_not sprintf('%d', 123.456);
-check_taint_not sprintf('%x', 123.456);
+# BE SURE TO COPY ANYTHING YOU ADD to these tests to the block below for
+# ":notcharacters"
+
+check_taint_not $a, '$a';
+
+check_taint uc($a), 'uc($a)';
+check_taint "\U$a", '"\U$a"';
+check_taint ucfirst($a), 'ucfirst($a)';
+check_taint "\u$a", '"\u$a"';
+check_taint lc($a), 'lc($a)';
+check_taint fc($a), 'fc($a)';
+check_taint "\L$a", '"\L$a"';
+check_taint "\F$a", '"\F$a"';
+check_taint lcfirst($a), 'lcfirst($a)';
+check_taint "\l$a", '"\l$a"';
+
+check_taint_not sprintf('%e', 123.456), "sprintf('%e', 123.456)";
+check_taint_not sprintf('%f', 123.456), "sprintf('%f', 123.456)";
+check_taint_not sprintf('%g', 123.456), "sprintf('%g', 123.456)";
+check_taint_not sprintf('%d', 123.456), "sprintf('%d', 123.456)";
+check_taint_not sprintf('%x', 123.456), "sprintf('%x', 123.456)";
$_ = $a; # untaint $_
$_ = uc($a); # taint $_
-check_taint $_, "\t\$_";
+check_taint $_, '$_ = uc($a)';
/(\w)/; # taint $&, $`, $', $+, $1.
-check_taint $&, "\t/(\\w)/ \$&";
+check_taint $&, "\$& from /(\\w)/";
check_taint $`, "\t\$`";
check_taint $', "\t\$'";
check_taint $+, "\t\$+";
check_taint_not $2, "\t\$2";
/(.)/; # untaint $&, $`, $', $+, $1.
-check_taint_not $&, "\t/(.)/ \$&";
+check_taint_not $&, "\$& from /(.)/";
check_taint_not $`, "\t\$`";
check_taint_not $', "\t\$'";
check_taint_not $+, "\t\$+";
check_taint_not $2, "\t\$2";
/(\W)/; # taint $&, $`, $', $+, $1.
-check_taint $&, "\t/(\\W)/ \$&";
+check_taint $&, "\$& from /(\\W)/";
check_taint $`, "\t\$`";
check_taint $', "\t\$'";
check_taint $+, "\t\$+";
check_taint_not $2, "\t\$2";
/(.)/; # untaint $&, $`, $', $+, $1.
-check_taint_not $&, "\t/(.)/ \$&";
+check_taint_not $&, "\$& from /(.)/";
check_taint_not $`, "\t\$`";
check_taint_not $', "\t\$'";
check_taint_not $+, "\t\$+";
check_taint_not $2, "\t\$2";
/(\s)/; # taint $&, $`, $', $+, $1.
-check_taint $&, "\t/(\\s)/ \$&";
+check_taint $&, "\$& from /(\\s)/";
check_taint $`, "\t\$`";
check_taint $', "\t\$'";
check_taint $+, "\t\$+";
check_taint_not $2, "\t\$2";
/(.)/; # untaint $&, $`, $', $+, $1.
-check_taint_not $&, "\t/(.)/ \$&";
+check_taint_not $&, "\$& from /(.)/";
/(\S)/; # taint $&, $`, $', $+, $1.
-check_taint $&, "\t/(\\S)/ \$&";
+check_taint $&, "\$& from /(\\S)/";
check_taint $`, "\t\$`";
check_taint $', "\t\$'";
check_taint $+, "\t\$+";
check_taint $1, "\t\$1";
check_taint_not $2, "\t\$2";
+/(.)/; # untaint $&, $`, $', $+, $1.
+check_taint_not $&, "\$& from /(.)/";
+
+"0" =~ /(\d)/; # taint $&, $`, $', $+, $1.
+check_taint $&, "\$& from /(\\d)/";
+check_taint $`, "\t\$`";
+check_taint $', "\t\$'";
+check_taint $+, "\t\$+";
+check_taint $1, "\t\$1";
+check_taint_not $2, "\t\$2";
+
+/(.)/; # untaint $&, $`, $', $+, $1.
+check_taint_not $&, "\$& from /(.)/";
+
+/(\D)/; # taint $&, $`, $', $+, $1.
+check_taint $&, "\$& from /(\\D)/";
+check_taint $`, "\t\$`";
+check_taint $', "\t\$'";
+check_taint $+, "\t\$+";
+check_taint $1, "\t\$1";
+check_taint_not $2, "\t\$2";
+
+/(.)/; # untaint $&, $`, $', $+, $1.
+check_taint_not $&, "\$& from /(.)/";
+
+/([[:alnum:]])/; # taint $&, $`, $', $+, $1.
+check_taint $&, "\$& from /([[:alnum:]])/";
+check_taint $`, "\t\$`";
+check_taint $', "\t\$'";
+check_taint $+, "\t\$+";
+check_taint $1, "\t\$1";
+check_taint_not $2, "\t\$2";
+
+/(.)/; # untaint $&, $`, $', $+, $1.
+check_taint_not $&, "\$& from /(.)/";
+
+/([[:^alnum:]])/; # taint $&, $`, $', $+, $1.
+check_taint $&, "\$& from /([[:^alnum:]])/";
+check_taint $`, "\t\$`";
+check_taint $', "\t\$'";
+check_taint $+, "\t\$+";
+check_taint $1, "\t\$1";
+check_taint_not $2, "\t\$2";
+
+"a" =~ /(a)|(\w)/; # taint $&, $`, $', $+, $1.
+check_taint $&, "\$& from /(a)|(\\w)/";
+check_taint $`, "\t\$`";
+check_taint $', "\t\$'";
+check_taint $+, "\t\$+";
+check_taint $1, "\t\$1";
+ok($1 eq 'a', ("\t" x 5) . "\$1 is 'a'");
+ok(! defined $2, ("\t" x 5) . "\$2 is undefined");
+check_taint_not $2, "\t\$2";
+check_taint_not $3, "\t\$3";
+
+/(.)/; # untaint $&, $`, $', $+, $1.
+check_taint_not $&, "\$& from /(.)/";
+
+"\N{CYRILLIC SMALL LETTER A}" =~ /(\N{CYRILLIC CAPITAL LETTER A})/i; # no tainting because no locale dependence
+check_taint_not $&, "\$& from /(\\N{CYRILLIC CAPITAL LETTER A})/i";
+check_taint_not $`, "\t\$`";
+check_taint_not $', "\t\$'";
+check_taint_not $+, "\t\$+";
+check_taint_not $1, "\t\$1";
+ok($1 eq "\N{CYRILLIC SMALL LETTER A}", ("\t" x 4) . "\t\$1 is 'small cyrillic a'");
+check_taint_not $2, "\t\$2";
+
+/(.)/; # untaint $&, $`, $', $+, $1.
+check_taint_not $&, "\$& from /./";
+
+"(\N{KELVIN SIGN})" =~ /(\N{KELVIN SIGN})/i; # taints because depends on locale
+check_taint $&, "\$& from /(\\N{KELVIN SIGN})/i";
+check_taint $`, "\t\$`";
+check_taint $', "\t\$'";
+check_taint $+, "\t\$+";
+check_taint $1, "\t\$1";
+check_taint_not $2, "\t\$2";
+
+/(.)/; # untaint $&, $`, $', $+, $1.
+check_taint_not $&, "\$& from /(.)/";
+
+"a:" =~ /(.)\b(.)/; # taint $&, $`, $', $+, $1.
+check_taint $&, "\$& from /(.)\\b(.)/";
+check_taint $`, "\t\$`";
+check_taint $', "\t\$'";
+check_taint $+, "\t\$+";
+check_taint $1, "\t\$1";
+check_taint $2, "\t\$2";
+check_taint_not $3, "\t\$3";
+
+/(.)/; # untaint $&, $`, $', $+, $1.
+check_taint_not $&, "\$& from /./";
+
+"aa" =~ /(.)\B(.)/; # taint $&, $`, $', $+, $1.
+check_taint $&, "\$& from /(.)\\B(.)/";
+check_taint $`, "\t\$`";
+check_taint $', "\t\$'";
+check_taint $+, "\t\$+";
+check_taint $1, "\t\$1";
+check_taint $2, "\t\$2";
+check_taint_not $3, "\t\$3";
+
+/(.)/; # untaint $&, $`, $', $+, $1.
+check_taint_not $&, "\$& from /./";
+
+"aaa" =~ /(.).(\1)/i; # notaint because not locale dependent
+check_taint_not $&, "\$ & from /(.).(\\1)/";
+check_taint_not $`, "\t\$`";
+check_taint_not $', "\t\$'";
+check_taint_not $+, "\t\$+";
+check_taint_not $1, "\t\$1";
+check_taint_not $2, "\t\$2";
+check_taint_not $3, "\t\$3";
+
+/(.)/; # untaint $&, $`, $', $+, $1.
+check_taint_not $&, "\$ & from /./";
+
$_ = $a; # untaint $_
-check_taint_not $_, "\t\$_";
+check_taint_not $_, 'untainting $_ works';
/(b)/; # this must not taint
-check_taint_not $&, "\t/(b)/ \$&";
+check_taint_not $&, "\$ & from /(b)/";
check_taint_not $`, "\t\$`";
check_taint_not $', "\t\$'";
check_taint_not $+, "\t\$+";
$_ = $a; # untaint $_
-check_taint_not $_, "\t\$_";
+check_taint_not $_, 'untainting $_ works';
$b = uc($a); # taint $b
s/(.+)/$b/; # this must taint only the $_
-check_taint $_, "\t\$_";
+check_taint $_, '$_ (wasn\'t tainted) from s/(.+)/$b/ where $b is tainted';
check_taint_not $&, "\t\$&";
check_taint_not $`, "\t\$`";
check_taint_not $', "\t\$'";
$_ = $a; # untaint $_
s/(.+)/b/; # this must not taint
-check_taint_not $_, "\t\$_";
+check_taint_not $_, '$_ (wasn\'t tainted) from s/(.+)/b/';
check_taint_not $&, "\t\$&";
check_taint_not $`, "\t\$`";
check_taint_not $', "\t\$'";
$b = $a; # untaint $b
($b = $a) =~ s/\w/$&/;
-check_taint $b, "\t\$b"; # $b should be tainted.
-check_taint_not $a, "\t\$a"; # $a should be not.
+check_taint $b, '$b from ($b = $a) =~ s/\w/$&/'; # $b should be tainted.
+check_taint_not $a, '$a from ($b = $a) =~ s/\w/$&/'; # $a should be not.
$_ = $a; # untaint $_
s/(\w)/\l$1/; # this must taint
-check_taint $_, "\t\$_";
+check_taint $_, '$_ (wasn\'t tainted) from s/(\w)/\l$1/,'; # this must taint
check_taint $&, "\t\$&";
check_taint $`, "\t\$`";
check_taint $', "\t\$'";
$_ = $a; # untaint $_
s/(\w)/\L$1/; # this must taint
-check_taint $_, "\t\$_";
+check_taint $_, '$_ (wasn\'t tainted) from s/(\w)/\L$1/,';
check_taint $&, "\t\$&";
check_taint $`, "\t\$`";
check_taint $', "\t\$'";
$_ = $a; # untaint $_
s/(\w)/\u$1/; # this must taint
-check_taint $_, "\t\$_";
+check_taint $_, '$_ (wasn\'t tainted) from s/(\w)/\u$1/';
check_taint $&, "\t\$&";
check_taint $`, "\t\$`";
check_taint $', "\t\$'";
$_ = $a; # untaint $_
s/(\w)/\U$1/; # this must taint
-check_taint $_, "\t\$_";
+check_taint $_, '$_ (wasn\'t tainted) from s/(\w)/\U$1/';
check_taint $&, "\t\$&";
check_taint $`, "\t\$`";
check_taint $', "\t\$'";
# After all this tainting $a should be cool.
-check_taint_not $a, "\t\$a";
+check_taint_not $a, '$a still not tainted';
"a" =~ /([a-z])/;
check_taint_not $1, '"a" =~ /([a-z])/';
use locale ':not_characters'; # engage restricted locale with different
# tainting rules
-
- check_taint_not $a;
-
- check_taint_not uc($a);
- check_taint_not "\U$a";
- check_taint_not ucfirst($a);
- check_taint_not "\u$a";
- check_taint_not lc($a);
- check_taint_not fc($a);
- check_taint_not "\L$a";
- check_taint_not "\F$a";
- check_taint_not lcfirst($a);
- check_taint_not "\l$a";
-
- check_taint_not sprintf('%e', 123.456);
- check_taint_not sprintf('%f', 123.456);
- check_taint_not sprintf('%g', 123.456);
- check_taint_not sprintf('%d', 123.456);
- check_taint_not sprintf('%x', 123.456);
+ check_taint_not $a, '$a';
+
+ check_taint_not uc($a), 'uc($a)';
+ check_taint_not "\U$a", '"\U$a"';
+ check_taint_not ucfirst($a), 'ucfirst($a)';
+ check_taint_not "\u$a", '"\u$a"';
+ check_taint_not lc($a), 'lc($a)';
+ check_taint_not fc($a), 'fc($a)';
+ check_taint_not "\L$a", '"\L$a"';
+ check_taint_not "\F$a", '"\F$a"';
+ check_taint_not lcfirst($a), 'lcfirst($a)';
+ check_taint_not "\l$a", '"\l$a"';
+
+ check_taint_not sprintf('%e', 123.456), "sprintf('%e', 123.456)";
+ check_taint_not sprintf('%f', 123.456), "sprintf('%f', 123.456)";
+ check_taint_not sprintf('%g', 123.456), "sprintf('%g', 123.456)";
+ check_taint_not sprintf('%d', 123.456), "sprintf('%d', 123.456)";
+ check_taint_not sprintf('%x', 123.456), "sprintf('%x', 123.456)";
$_ = $a; # untaint $_
- $_ = uc($a); # taint $_
+ $_ = uc($a);
- check_taint_not $_;
+ check_taint_not $_, '$_ = uc($a)';
- /(\w)/; # taint $&, $`, $', $+, $1.
- check_taint_not $&;
- check_taint_not $`;
- check_taint_not $';
- check_taint_not $+;
- check_taint_not $1;
- check_taint_not $2;
+ /(\w)/;
+ check_taint_not $&, "\$& from /(\\w)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
/(.)/; # untaint $&, $`, $', $+, $1.
- check_taint_not $&;
- check_taint_not $`;
- check_taint_not $';
- check_taint_not $+;
- check_taint_not $1;
- check_taint_not $2;
-
- /(\W)/; # taint $&, $`, $', $+, $1.
- check_taint_not $&;
- check_taint_not $`;
- check_taint_not $';
- check_taint_not $+;
- check_taint_not $1;
- check_taint_not $2;
-
- /(\s)/; # taint $&, $`, $', $+, $1.
- check_taint_not $&;
- check_taint_not $`;
- check_taint_not $';
- check_taint_not $+;
- check_taint_not $1;
- check_taint_not $2;
-
- /(\S)/; # taint $&, $`, $', $+, $1.
- check_taint_not $&;
- check_taint_not $`;
- check_taint_not $';
- check_taint_not $+;
- check_taint_not $1;
- check_taint_not $2;
+ check_taint_not $&, "\$& from /(.)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
+
+ /(\W)/;
+ check_taint_not $&, "\$& from /(\\W)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
- $_ = $a; # untaint $_
+ /(.)/; # untaint $&, $`, $', $+, $1.
+ check_taint_not $&, "\$& from /(.)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
+
+ /(\s)/;
+ check_taint_not $&, "\$& from /(\\s)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
- check_taint_not $_;
+ /(.)/; # untaint $&, $`, $', $+, $1.
+ check_taint_not $&, "\$& from /(.)/";
- /(b)/; # this must not taint
- check_taint_not $&;
- check_taint_not $`;
- check_taint_not $';
- check_taint_not $+;
- check_taint_not $1;
- check_taint_not $2;
+ /(\S)/;
+ check_taint_not $&, "\$& from /(\\S)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
- $_ = $a; # untaint $_
+ /(.)/; # untaint $&, $`, $', $+, $1.
+ check_taint_not $&, "\$& from /(.)/";
+
+ "0" =~ /(\d)/;
+ check_taint_not $&, "\$& from /(\\d)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
- check_taint_not $_;
+ /(.)/; # untaint $&, $`, $', $+, $1.
+ check_taint_not $&, "\$& from /(.)/";
- $b = uc($a); # taint $b
- s/(.+)/$b/; # this must taint only the $_
+ /(\D)/;
+ check_taint_not $&, "\$& from /(\\D)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
+
+ /(.)/; # untaint $&, $`, $', $+, $1.
+ check_taint_not $&, "\$& from /(.)/";
- check_taint_not $_;
- check_taint_not $&;
- check_taint_not $`;
- check_taint_not $';
- check_taint_not $+;
- check_taint_not $1;
- check_taint_not $2;
+ /([[:alnum:]])/;
+ check_taint_not $&, "\$& from /([[:alnum:]])/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
+
+ /(.)/; # untaint $&, $`, $', $+, $1.
+ check_taint_not $&, "\$& from /(.)/";
+
+ /([[:^alnum:]])/;
+ check_taint_not $&, "\$& from /([[:^alnum:]])/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
+
+ "a" =~ /(a)|(\w)/;
+ check_taint_not $&, "\$& from /(a)|(\\w)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ ok($1 eq 'a', ("\t" x 5) . "\$1 is 'a'");
+ ok(! defined $2, ("\t" x 5) . "\$2 is undefined");
+ check_taint_not $2, "\t\$2";
+ check_taint_not $3, "\t\$3";
+
+ /(.)/; # untaint $&, $`, $', $+, $1.
+ check_taint_not $&, "\$& from /(.)/";
+
+ "\N{CYRILLIC SMALL LETTER A}" =~ /(\N{CYRILLIC CAPITAL LETTER A})/i;
+ check_taint_not $&, "\$& from /(\\N{CYRILLIC CAPITAL LETTER A})/i";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ ok($1 eq "\N{CYRILLIC SMALL LETTER A}", ("\t" x 4) . "\t\$1 is 'small cyrillic a'");
+ check_taint_not $2, "\t\$2";
+
+ /(.)/; # untaint $&, $`, $', $+, $1.
+ check_taint_not $&, "\$& from /./";
+
+ "(\N{KELVIN SIGN})" =~ /(\N{KELVIN SIGN})/i;
+ check_taint_not $&, "\$& from /(\\N{KELVIN SIGN})/i";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
+
+ /(.)/; # untaint $&, $`, $', $+, $1.
+ check_taint_not $&, "\$& from /(.)/";
+
+ "a:" =~ /(.)\b(.)/;
+ check_taint_not $&, "\$& from /(.)\\b(.)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
+ check_taint_not $3, "\t\$3";
+
+ /(.)/; # untaint $&, $`, $', $+, $1.
+ check_taint_not $&, "\$& from /./";
+
+ "aa" =~ /(.)\B(.)/;
+ check_taint_not $&, "\$& from /(.)\\B(.)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
+ check_taint_not $3, "\t\$3";
+
+ /(.)/; # untaint $&, $`, $', $+, $1.
+ check_taint_not $&, "\$& from /./";
+
+ "aaa" =~ /(.).(\1)/i; # notaint because not locale dependent
+ check_taint_not $&, "\$ & from /(.).(\\1)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
+ check_taint_not $3, "\t\$3";
+
+ /(.)/; # untaint $&, $`, $', $+, $1.
+ check_taint_not $&, "\$ & from /./";
+
+ $_ = $a; # untaint $_
+
+ check_taint_not $_, 'untainting $_ works';
+
+ /(b)/;
+ check_taint_not $&, "\$ & from /(b)/";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
$_ = $a; # untaint $_
- s/(.+)/b/; # this must not taint
- check_taint_not $_;
- check_taint_not $&;
- check_taint_not $`;
- check_taint_not $';
- check_taint_not $+;
- check_taint_not $1;
- check_taint_not $2;
+ check_taint_not $_, 'untainting $_ works';
+
+ s/(.+)/b/;
+ check_taint_not $_, '$_ (wasn\'t tainted) from s/(.+)/b/';
+ check_taint_not $&, "\t\$&";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
$b = $a; # untaint $b
($b = $a) =~ s/\w/$&/;
- check_taint_not $b; # $b should be tainted.
- check_taint_not $a; # $a should be not.
+ check_taint_not $b, '$b from ($b = $a) =~ s/\w/$&/';
+ check_taint_not $a, '$a from ($b = $a) =~ s/\w/$&/';
$_ = $a; # untaint $_
- s/(\w)/\l$1/; # this must taint
- check_taint_not $_;
- check_taint_not $&;
- check_taint_not $`;
- check_taint_not $';
- check_taint_not $+;
- check_taint_not $1;
- check_taint_not $2;
+ s/(\w)/\l$1/;
+ check_taint_not $_, '$_ (wasn\'t tainted) from s/(\w)/\l$1/,'; # this must taint
+ check_taint_not $&, "\t\$&";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
$_ = $a; # untaint $_
- s/(\w)/\L$1/; # this must taint
- check_taint_not $_;
- check_taint_not $&;
- check_taint_not $`;
- check_taint_not $';
- check_taint_not $+;
- check_taint_not $1;
- check_taint_not $2;
+ s/(\w)/\L$1/;
+ check_taint_not $_, '$_ (wasn\'t tainted) from s/(\w)/\L$1/,';
+ check_taint_not $&, "\t\$&";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
$_ = $a; # untaint $_
- s/(\w)/\u$1/; # this must taint
- check_taint_not $_;
- check_taint_not $&;
- check_taint_not $`;
- check_taint_not $';
- check_taint_not $+;
- check_taint_not $1;
- check_taint_not $2;
+ s/(\w)/\u$1/;
+ check_taint_not $_, '$_ (wasn\'t tainted) from s/(\w)/\u$1/';
+ check_taint_not $&, "\t\$&";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
$_ = $a; # untaint $_
- s/(\w)/\U$1/; # this must taint
- check_taint_not $_;
- check_taint_not $&;
- check_taint_not $`;
- check_taint_not $';
- check_taint_not $+;
- check_taint_not $1;
- check_taint_not $2;
+ s/(\w)/\U$1/;
+ check_taint_not $_, '$_ (wasn\'t tainted) from s/(\w)/\U$1/';
+ check_taint_not $&, "\t\$&";
+ check_taint_not $`, "\t\$`";
+ check_taint_not $', "\t\$'";
+ check_taint_not $+, "\t\$+";
+ check_taint_not $1, "\t\$1";
+ check_taint_not $2, "\t\$2";
# After all this tainting $a should be cool.
- check_taint_not $a;
+ check_taint_not $a, '$a still not tainted';
"a" =~ /([a-z])/;
check_taint_not $1, '"a" =~ /([a-z])/';
"foo.bar_baz" =~ /^(.*)[._](.*?)$/; # Bug 120675
check_taint_not $1, '"foo.bar_baz" =~ /^(.*)[._](.*?)$/';
+
}
# Here are in scope of 'use locale'
# Find locales.
-debug "# Scanning for locales...\n";
+debug "Scanning for locales...\n";
require POSIX; import POSIX ':locale_h';
-my @Locale = find_locales([ &POSIX::LC_CTYPE, &POSIX::LC_ALL ]);
+my @Locale = find_locales([ &POSIX::LC_CTYPE, &POSIX::LC_NUMERIC, &POSIX::LC_ALL ]);
-debug "# Locales =\n";
+debug "Locales =\n";
for ( @Locale ) {
- debug "# $_\n";
+ debug "$_\n";
}
unless (@Locale) {
return $output;
}
+sub disp_str ($) {
+ my $string = shift;
+
+ # Displays the string unambiguously. ASCII printables are always output
+ # as-is, though perhaps separated by blanks from other characters. If
+ # entirely printable ASCII, just returns the string. Otherwise if valid
+ # UTF-8 it uses the character names for non-printable-ASCII. Otherwise it
+ # outputs hex for each non-ASCII-printable byte.
+
+ return $string if $string =~ / ^ [[:print:]]* $/xa;
+
+ my $result = "";
+ my $prev_was_punct = 1; # Beginning is considered punct
+ if (utf8::valid($string) && utf8::is_utf8($string)) {
+ use charnames ();
+ foreach my $char (split "", $string) {
+
+ # Keep punctuation adjacent to other characters; otherwise
+ # separate them with a blank
+ if ($char =~ /[[:punct:]]/a) {
+ $result .= $char;
+ $prev_was_punct = 1;
+ }
+ elsif ($char =~ /[[:print:]]/a) {
+ $result .= " " unless $prev_was_punct;
+ $result .= $char;
+ $prev_was_punct = 0;
+ }
+ else {
+ $result .= " " unless $prev_was_punct;
+ $result .= charnames::viacode(ord $char);
+ $prev_was_punct = 0;
+ }
+ }
+ }
+ else {
+ use bytes;
+ foreach my $char (split "", $string) {
+ if ($char =~ /[[:punct:]]/a) {
+ $result .= $char;
+ $prev_was_punct = 1;
+ }
+ elsif ($char =~ /[[:print:]]/a) {
+ $result .= " " unless $prev_was_punct;
+ $result .= $char;
+ $prev_was_punct = 0;
+ }
+ else {
+ $result .= " " unless $prev_was_punct;
+ $result .= sprintf("%02X", ord $char);
+ $prev_was_punct = 0;
+ }
+ }
+ }
+
+ return $result;
+}
+
sub report_result {
my ($Locale, $i, $pass_fail, $message) = @_;
$message //= "";
$message = " ($message)" if $message;
unless ($pass_fail) {
$Problem{$i}{$Locale} = 1;
- debug "# failed $i ($test_names{$i}) with locale '$Locale'$message\n";
+ debug "failed $i ($test_names{$i}) with locale '$Locale'$message\n";
} else {
push @{$Okay{$i}}, $Locale;
}
foreach my $Locale (@Locale) {
$locales_test_number = $first_locales_test_number - 1;
- debug "#\n";
- debug "# Locale = $Locale\n";
+ debug "\n";
+ debug "Locale = $Locale\n";
unless (setlocale(&POSIX::LC_ALL, $Locale)) {
$setlocale_failed{$Locale} = $Locale;
my $is_utf8_locale = is_locale_utf8($Locale);
- debug "# is utf8 locale? = $is_utf8_locale\n";
+ debug "is utf8 locale? = $is_utf8_locale\n";
- my $radix = localeconv()->{decimal_point};
- if ($radix !~ / ^ [[:ascii:]] + $/x) {
- use bytes;
- $radix = disp_chars(split "", $radix);
- }
- debug "# radix = $radix\n";
+ debug "radix = " . disp_str(localeconv()->{decimal_point}) . "\n";
if (! $is_utf8_locale) {
use locale;
# Ordered, where possible, in groups of "this is a subset of the next
# one"
- debug "# :upper: = ", disp_chars(@{$posixes{'upper'}}), "\n";
- debug "# :lower: = ", disp_chars(@{$posixes{'lower'}}), "\n";
- debug "# :cased: = ", disp_chars(@{$posixes{'cased'}}), "\n";
- debug "# :alpha: = ", disp_chars(@{$posixes{'alpha'}}), "\n";
- debug "# :alnum: = ", disp_chars(@{$posixes{'alnum'}}), "\n";
- debug "# w = ", disp_chars(@{$posixes{'word'}}), "\n";
- debug "# :graph: = ", disp_chars(@{$posixes{'graph'}}), "\n";
- debug "# :print: = ", disp_chars(@{$posixes{'print'}}), "\n";
- debug "# d = ", disp_chars(@{$posixes{'digit'}}), "\n";
- debug "# :xdigit: = ", disp_chars(@{$posixes{'xdigit'}}), "\n";
- debug "# :blank: = ", disp_chars(@{$posixes{'blank'}}), "\n";
- debug "# s = ", disp_chars(@{$posixes{'space'}}), "\n";
- debug "# :punct: = ", disp_chars(@{$posixes{'punct'}}), "\n";
- debug "# :cntrl: = ", disp_chars(@{$posixes{'cntrl'}}), "\n";
- debug "# :ascii: = ", disp_chars(@{$posixes{'ascii'}}), "\n";
+ debug ":upper: = ", disp_chars(@{$posixes{'upper'}}), "\n";
+ debug ":lower: = ", disp_chars(@{$posixes{'lower'}}), "\n";
+ debug ":cased: = ", disp_chars(@{$posixes{'cased'}}), "\n";
+ debug ":alpha: = ", disp_chars(@{$posixes{'alpha'}}), "\n";
+ debug ":alnum: = ", disp_chars(@{$posixes{'alnum'}}), "\n";
+ debug " w = ", disp_chars(@{$posixes{'word'}}), "\n";
+ debug ":graph: = ", disp_chars(@{$posixes{'graph'}}), "\n";
+ debug ":print: = ", disp_chars(@{$posixes{'print'}}), "\n";
+ debug " d = ", disp_chars(@{$posixes{'digit'}}), "\n";
+ debug ":xdigit: = ", disp_chars(@{$posixes{'xdigit'}}), "\n";
+ debug ":blank: = ", disp_chars(@{$posixes{'blank'}}), "\n";
+ debug " s = ", disp_chars(@{$posixes{'space'}}), "\n";
+ debug ":punct: = ", disp_chars(@{$posixes{'punct'}}), "\n";
+ debug ":cntrl: = ", disp_chars(@{$posixes{'cntrl'}}), "\n";
+ debug ":ascii: = ", disp_chars(@{$posixes{'ascii'}}), "\n";
foreach (keys %UPPER) {
}
}
- debug "# UPPER = ", disp_chars(sort { ord $a <=> ord $b } keys %UPPER), "\n";
- debug "# lower = ", disp_chars(sort { ord $a <=> ord $b } keys %lower), "\n";
- debug "# BoThCaSe = ", disp_chars(sort { ord $a <=> ord $b } keys %BoThCaSe), "\n";
- debug "# Unassigned = ", disp_chars(sort { ord $a <=> ord $b } keys %Unassigned), "\n";
+ debug "UPPER = ", disp_chars(sort { ord $a <=> ord $b } keys %UPPER), "\n";
+ debug "lower = ", disp_chars(sort { ord $a <=> ord $b } keys %lower), "\n";
+ debug "BoThCaSe = ", disp_chars(sort { ord $a <=> ord $b } keys %BoThCaSe), "\n";
+ debug "Unassigned = ", disp_chars(sort { ord $a <=> ord $b } keys %Unassigned), "\n";
my @failures;
my @fold_failures;
@Added_alpha = sort { ord $a <=> ord $b } @Added_alpha;
- debug "# Added_alpha = ", disp_chars(@Added_alpha), "\n";
+ debug "Added_alpha = ", disp_chars(@Added_alpha), "\n";
# Cross-check the whole 8-bit character set.
++$locales_test_number;
undef @f;
- $test_names{$locales_test_number} = 'Verify that [:digit:] is a subset of [:xdigit:]';
+ my @xdigit_digits; # :digit: & :xdigit:
+ $test_names{$locales_test_number} = 'Verify that [:xdigit:] contains one or two blocks of 10 consecutive [:digit:] chars';
for (map { chr } 0..255) {
if ($is_utf8_locale) {
use locale ':not_characters';
- push @f, $_ if /[[:digit:]]/ and ! /[[:xdigit:]]/;
+ # For utf8 locales, we actually use a stricter test: that :digit:
+ # is a subset of :xdigit:, as we know that only 0-9 should match
+ push @f, $_ if /[[:digit:]]/ and ! /[[:xdigit:]]/;
+ }
+ else {
+ push @xdigit_digits, $_ if /[[:digit:]]/ and /[[:xdigit:]]/;
+ }
+ }
+ if (! $is_utf8_locale) {
+
+ # For non-utf8 locales, @xdigit_digits is a list of the characters
+ # that are both :xdigit: and :digit:. Because :digit: is stored in
+ # increasing code point order (unless the tests above failed),
+ # @xdigit_digits is as well. There should be exactly 10 or
+ # 20 of these.
+ if (@xdigit_digits != 10 && @xdigit_digits != 20) {
+ @f = @xdigit_digits;
}
else {
- push @f, $_ if /[[:digit:]]/ and ! /[[:xdigit:]]/;
+
+ # Look for contiguity in the series, adding any wrong ones to @f
+ my @temp = @xdigit_digits;
+ while (@temp > 1) {
+ push @f, $temp[1] if ($temp[0] != $temp[1] - 1)
+
+ # Skip this test for the 0th character of
+ # the second block of 10, as it won't be
+ # contiguous with the previous block
+ && (! defined $xdigit_digits[10]
+ || $temp[1] != $xdigit_digits[10]);
+ shift @temp;
+ }
}
}
+
report_multi_result($Locale, $locales_test_number, \@f);
++$locales_test_number;
$test_names{$locales_test_number} = 'Verify that any additional members of [:xdigit:], are in groups of 6 consecutive code points';
my $previous_ord;
my $count = 0;
- for (map { chr } 0..255) {
- next unless /[[:xdigit:]]/;
- next if /[[:digit:]]/;
- next if /[A-Fa-f]/;
+ for my $chr (map { chr } 0..255) {
+ next unless $chr =~ /[[:xdigit:]]/;
+ if ($is_utf8_locale) {
+ next if $chr =~ /[[:digit:]]/;
+ }
+ else {
+ next if grep { $chr eq $_ } @xdigit_digits;
+ }
+ next if $chr =~ /[A-Fa-f]/;
if (defined $previous_ord) {
if ($is_utf8_locale) {
use locale ':not_characters';
- push @f, $_ if ord $_ != $previous_ord + 1;
+ push @f, $chr if ord $chr != $previous_ord + 1;
}
else {
- push @f, $_ if ord $_ != $previous_ord + 1;
+ push @f, $chr if ord $chr != $previous_ord + 1;
}
}
$count++;
undef $previous_ord;
}
else {
- $previous_ord = ord $_;
+ $previous_ord = ord $chr;
}
}
report_multi_result($Locale, $locales_test_number, \@f);
report_multi_result($Locale, $locales_test_number, \@f);
foreach ($first_casing_test_number..$locales_test_number) {
- push @problematical_tests, $_;
+ $problematical_tests{$_} = 1;
}
}
report_result($Locale, $locales_test_number, $test == 0);
if ($test) {
- debug "# lesser = '$lesser'\n";
- debug "# greater = '$greater'\n";
- debug "# lesser cmp greater = ",
+ debug "lesser = '$lesser'\n";
+ debug "greater = '$greater'\n";
+ debug "lesser cmp greater = ",
$lesser cmp $greater, "\n";
- debug "# greater cmp lesser = ",
+ debug "greater cmp lesser = ",
$greater cmp $lesser, "\n";
- debug "# (greater) from = $from, to = $to\n";
+ debug "(greater) from = $from, to = $to\n";
for my $ti (@test) {
debugf("# %-40s %-4s", $ti,
$test{$ti} ? 'FAIL' : 'ok');
if ($ti =~ /\(\.*(\$.+ +cmp +\$[^\)]+)\.*\)/) {
debugf("(%s == %4d)", $1, eval $1);
}
- debug "\n#";
+ debugf("\n#");
}
last;
my $ok12;
my $ok13;
my $ok14;
+ my $ok14_5;
my $ok15;
my $ok16;
my $ok17;
my $ok18;
+ my $ok19;
+ my $ok20;
+ my $ok21;
my $c;
my $d;
$ok11 = $f == $c;
$ok12 = abs(($f + $g) - 3.57) < 0.01;
$ok13 = $w == 0;
- $ok14 = $ok15 = $ok16 = 1; # Skip for non-utf8 locales
+ $ok14 = $ok14_5 = $ok15 = $ok16 = 1; # Skip for non-utf8 locales
}
{
no locale;
# Look for non-ASCII error messages, and verify that the first
# such is in UTF-8 (the others almost certainly will be like the
- # first).
+ # first). This is only done if the current locale has LC_MESSAGES
$ok14 = 1;
- foreach my $err (keys %!) {
- use Errno;
- $! = eval "&Errno::$err"; # Convert to strerror() output
- my $strerror = "$!";
- if ("$strerror" =~ /\P{ASCII}/) {
- $ok14 = utf8::is_utf8($strerror);
- last;
+ $ok14_5 = 1;
+ if (setlocale(&POSIX::LC_MESSAGES, $Locale)) {
+ foreach my $err (keys %!) {
+ use Errno;
+ $! = eval "&Errno::$err"; # Convert to strerror() output
+ my $strerror = "$!";
+ if ("$strerror" =~ /\P{ASCII}/) {
+ $ok14 = utf8::is_utf8($strerror);
+ no locale;
+ $ok14_5 = "$!" !~ /\P{ASCII}/;
+ last;
+ }
}
}
$ok18 = $j eq sprintf("%g:%g", $h, $i);
}
+ $ok19 = $ok20 = 1;
+ if (setlocale(&POSIX::LC_TIME, $Locale)) { # These tests aren't affected by
+ # :not_characters
+ my @times = CORE::localtime();
+
+ use locale;
+ $ok19 = POSIX::strftime("%p", @times) ne "%p"; # [perl #119425]
+ my $date = POSIX::strftime("'%A' '%B' '%Z' '%p'", @times);
+ debug("'Day' 'Month' 'TZ' 'am/pm' = ", disp_str($date));
+
+ # If there is any non-ascii, it better be UTF-8 in a UTF-8 locale, and
+ # not UTF-8 if the locale isn't UTF-8.
+ $ok20 = $date =~ / ^ \p{ASCII}+ $ /x
+ || $is_utf8_locale == utf8::is_utf8($date);
+ }
+
+ $ok21 = 1;
+ foreach my $err (keys %!) {
+ no locale;
+ use Errno;
+ $! = eval "&Errno::$err"; # Convert to strerror() output
+ my $strerror = "$!";
+ if ("$strerror" =~ /\P{ASCII}/) {
+ $ok21 = 0;
+ last;
+ }
+ }
+
report_result($Locale, ++$locales_test_number, $ok1);
$test_names{$locales_test_number} = 'Verify that an intervening printf doesn\'t change assignment results';
my $first_a_test = $locales_test_number;
- debug "# $first_a_test..$locales_test_number: \$a = $a, \$b = $b, Locale = $Locale\n";
+ debug "$first_a_test..$locales_test_number: \$a = $a, \$b = $b, Locale = $Locale\n";
report_result($Locale, ++$locales_test_number, $ok2);
$test_names{$locales_test_number} = 'Verify that an intervening sprintf doesn\'t change assignment results';
report_result($Locale, ++$locales_test_number, $ok3);
$test_names{$locales_test_number} = 'Verify that a different locale radix works when doing "==" with a constant';
+ $problematical_tests{$locales_test_number} = 1;
report_result($Locale, ++$locales_test_number, $ok4);
$test_names{$locales_test_number} = 'Verify that a different locale radix works when doing "==" with a scalar';
+ $problematical_tests{$locales_test_number} = 1;
report_result($Locale, ++$locales_test_number, $ok5);
$test_names{$locales_test_number} = 'Verify that a different locale radix works when doing "==" with a scalar and an intervening sprintf';
+ $problematical_tests{$locales_test_number} = 1;
- debug "# $first_c_test..$locales_test_number: \$c = $c, \$d = $d, Locale = $Locale\n";
+ debug "$first_c_test..$locales_test_number: \$c = $c, \$d = $d, Locale = $Locale\n";
report_result($Locale, ++$locales_test_number, $ok6);
$test_names{$locales_test_number} = 'Verify that can assign stringified under inner no-locale block';
report_result($Locale, ++$locales_test_number, $ok8);
$test_names{$locales_test_number} = 'Verify that "==" with a scalar and an intervening sprintf still works in inner no locale';
+ $problematical_tests{$locales_test_number} = 1;
- debug "# $first_e_test..$locales_test_number: \$e = $e, no locale\n";
+ debug "$first_e_test..$locales_test_number: \$e = $e, no locale\n";
report_result($Locale, ++$locales_test_number, $ok9);
$test_names{$locales_test_number} = 'Verify that after a no-locale block, a different locale radix still works when doing "==" with a constant';
+ $problematical_tests{$locales_test_number} = 1;
my $first_f_test = $locales_test_number;
report_result($Locale, ++$locales_test_number, $ok10);
$test_names{$locales_test_number} = 'Verify that after a no-locale block, a different locale radix still works when doing "==" with a scalar';
+ $problematical_tests{$locales_test_number} = 1;
report_result($Locale, ++$locales_test_number, $ok11);
$test_names{$locales_test_number} = 'Verify that after a no-locale block, a different locale radix still works when doing "==" with a scalar and an intervening sprintf';
+ $problematical_tests{$locales_test_number} = 1;
report_result($Locale, ++$locales_test_number, $ok12);
$test_names{$locales_test_number} = 'Verify that after a no-locale block, a different locale radix can participate in an addition and function call as numeric';
+ $problematical_tests{$locales_test_number} = 1;
report_result($Locale, ++$locales_test_number, $ok13);
$test_names{$locales_test_number} = 'Verify that don\'t get warning under "==" even if radix is not a dot';
+ $problematical_tests{$locales_test_number} = 1;
report_result($Locale, ++$locales_test_number, $ok14);
$test_names{$locales_test_number} = 'Verify that non-ASCII UTF-8 error messages are in UTF-8';
+ report_result($Locale, ++$locales_test_number, $ok14_5);
+ $test_names{$locales_test_number} = '... and are ASCII outside "use locale"';
+
report_result($Locale, ++$locales_test_number, $ok15);
$test_names{$locales_test_number} = 'Verify that a number with a UTF-8 radix has a UTF-8 stringification';
report_result($Locale, ++$locales_test_number, $ok18);
$test_names{$locales_test_number} = 'Verify that a sprintf of a number back within locale scope uses locale radix';
- debug "# $first_f_test..$locales_test_number: \$f = $f, \$g = $g, back to locale = $Locale\n";
+ report_result($Locale, ++$locales_test_number, $ok19);
+ $test_names{$locales_test_number} = 'Verify that strftime doesn\'t return "%p" in locales where %p is empty';
+
+ report_result($Locale, ++$locales_test_number, $ok20);
+ $test_names{$locales_test_number} = 'Verify that strftime returns date with UTF-8 flag appropriately set';
+ $problematical_tests{$locales_test_number} = 1; # This is broken in
+ # OS X 10.9.3
+
+ report_result($Locale, ++$locales_test_number, $ok21);
+ $test_names{$locales_test_number} = '"$!" is ASCII only outside of locale scope';
+
+ debug "$first_f_test..$locales_test_number: \$f = $f, \$g = $g, back to locale = $Locale\n";
# Does taking lc separately differ from taking
# the lc "in-line"? (This was the bug 19990704.002, change #3568.)
if (! $is_utf8_locale) {
my $y = lc $x;
next unless uc $y eq $x;
- debug_more( "# UPPER=", disp_chars(($x)),
+ debug_more( "UPPER=", disp_chars(($x)),
"; lc=", disp_chars(($y)), "; ",
"; fc=", disp_chars((fc $x)), "; ",
disp_chars(($x)), "=~/", disp_chars(($y)), "/i=",
use locale ':not_characters';
my $y = lc $x;
next unless uc $y eq $x;
- debug_more( "# UPPER=", disp_chars(($x)),
+ debug_more( "UPPER=", disp_chars(($x)),
"; lc=", disp_chars(($y)), "; ",
"; fc=", disp_chars((fc $x)), "; ",
disp_chars(($x)), "=~/", disp_chars(($y)), "/i=",
if (! $is_utf8_locale) {
my $y = uc $x;
next unless lc $y eq $x;
- debug_more( "# lower=", disp_chars(($x)),
+ debug_more( "lower=", disp_chars(($x)),
"; uc=", disp_chars(($y)), "; ",
"; fc=", disp_chars((fc $x)), "; ",
disp_chars(($x)), "=~/", disp_chars(($y)), "/i=",
use locale ':not_characters';
my $y = uc $x;
next unless lc $y eq $x;
- debug_more( "# lower=", disp_chars(($x)),
+ debug_more( "lower=", disp_chars(($x)),
"; uc=", disp_chars(($y)), "; ",
"; fc=", disp_chars((fc $x)), "; ",
disp_chars(($x)), "=~/", disp_chars(($y)), "/i=",
}
}
report_multi_result($Locale, $locales_test_number, \@f);
- push @problematical_tests, $locales_test_number;
+ $problematical_tests{$locales_test_number} = 1;
}
# [perl #109318]
my @f = ();
++$locales_test_number;
$test_names{$locales_test_number} = 'Verify atof with locale radix and negative exponent';
+ $problematical_tests{$locales_test_number} = 1;
my $radix = POSIX::localeconv()->{decimal_point};
my @nums = (
print "# It usually indicates a problem in the environment,\n";
print "# not in Perl itself.\n";
}
- if ($Okay{$test_num} && grep { $_ == $test_num } @problematical_tests) {
+ if ($Okay{$test_num} && grep { $_ == $test_num } keys %problematical_tests) {
no warnings 'experimental::autoderef';
# Round to nearest .1%
my $percent_fail = (int(.5 + (1000 * scalar(keys $Problem{$test_num})
/ scalar(@Locale))))
/ 10;
- if (! $debug && $percent_fail < $acceptable_fold_failure_percentage)
- {
- $test_names{$test_num} .= 'TODO';
- print "# ", 100 - $percent_fail, "% of locales pass the following test, so it is likely that the failures\n";
- print "# are errors in the locale definitions. The test is marked TODO, as the\n";
- print "# problem is not likely to be Perl's\n";
+ if ($percent_fail < $acceptable_failure_percentage) {
+ if (! $debug) {
+ $test_names{$test_num} .= 'TODO';
+ print "# ", 100 - $percent_fail, "% of locales pass the following test, so it is likely that the failures\n";
+ print "# are errors in the locale definitions. The test is marked TODO, as the\n";
+ print "# problem is not likely to be Perl's\n";
+ }
+ }
+ if ($debug) {
+ print "# $percent_fail% of locales (",
+ scalar(keys $Problem{$test_num}),
+ " of ",
+ scalar(@Locale),
+ ") fail the above test (TODO cut-off is ",
+ $acceptable_failure_percentage,
+ "%)\n";
}
}
print "#\n";
my $s = join(" ", @s);
$s =~ s/(.{50,60}) /$1\n#\t/g;
- warn
+ print
"# The following locales\n#\n",
"#\t", $s, "\n#\n",
"# tested okay.\n#\n",
} else {
- warn "# None of your locales were fully okay.\n";
+ print "# None of your locales were fully okay.\n";
}
if (@F) {
$details = "# For even more details, rerun, with environment variable PERL_DEBUG_FULL_TEST=2.\n";
}
- warn
+ print
"# The following locales\n#\n",
"#\t", $F, "\n#\n",
"# had problems.\n#\n",
$details;
} else {
- warn "# None of your locales were broken.\n";
+ print "# None of your locales were broken.\n";
}
}