dslinux/user/perl/ext/XS/APItest/t call.t hash.t printf.t push.t
cayenne
dslinux_cayenne at user.in-berlin.de
Tue Dec 5 05:27:01 CET 2006
Update of /cvsroot/dslinux/dslinux/user/perl/ext/XS/APItest/t
In directory antilope:/tmp/cvs-serv7729/ext/XS/APItest/t
Added Files:
call.t hash.t printf.t push.t
Log Message:
Adding fresh perl source to HEAD to branch from
--- NEW FILE: hash.t ---
#!perl -w
BEGIN {
chdir 't' if -d 't';
@INC = '../lib';
push @INC, "::lib:$MacPerl::Architecture:" if $^O eq 'MacOS';
require Config; import Config;
if ($Config{'extensions'} !~ /\bXS\/APItest\b/) {
# Look, I'm using this fully-qualified variable more than once!
my $arch = $MacPerl::Architecture;
print "1..0 # Skip: XS::APItest was not built\n";
exit 0;
}
}
use strict;
use utf8;
use Tie::Hash;
use Test::More 'no_plan';
use_ok('XS::APItest');
sub preform_test;
sub test_present;
sub test_absent;
sub test_delete_present;
sub test_delete_absent;
sub brute_force_exists;
sub test_store;
sub test_fetch_present;
sub test_fetch_absent;
my $utf8_for_258 = chr 258;
utf8::encode $utf8_for_258;
my @testkeys = ('N', chr 198, chr 256);
my @keys = (@testkeys, $utf8_for_258);
foreach (@keys) {
utf8::downgrade $_, 1;
}
main_tests (\@keys, \@testkeys, '');
foreach (@keys) {
utf8::upgrade $_;
}
main_tests (\@keys, \@testkeys, ' [utf8 hash]');
{
my %h = (a=>'cheat');
tie %h, 'Tie::StdHash';
is (XS::APItest::Hash::store(\%h, chr 258, 1), 1);
ok (!exists $h{$utf8_for_258},
"hv_store doesn't insert a key with the raw utf8 on a tied hash");
}
exit;
################################ The End ################################
sub main_tests {
my ($keys, $testkeys, $description) = @_;
foreach my $key (@$testkeys) {
my $lckey = ($key eq chr 198) ? chr 230 : lc $key;
my $unikey = $key;
utf8::encode $unikey;
utf8::downgrade $key, 1;
utf8::downgrade $lckey, 1;
utf8::downgrade $unikey, 1;
main_test_inner ($key, $lckey, $unikey, $keys, $description);
utf8::upgrade $key;
utf8::upgrade $lckey;
utf8::upgrade $unikey;
main_test_inner ($key, $lckey, $unikey, $keys,
$description . ' [key utf8 on]');
}
# hv_exists was buggy for tied hashes, in that the raw utf8 key was being
# used - the utf8 flag was being lost.
perform_test (\&test_absent, (chr 258), $keys, '');
perform_test (\&test_fetch_absent, (chr 258), $keys, '');
perform_test (\&test_delete_absent, (chr 258), $keys, '');
}
sub main_test_inner {
my ($key, $lckey, $unikey, $keys, $description) = @_;
perform_test (\&test_present, $key, $keys, $description);
perform_test (\&test_fetch_present, $key, $keys, $description);
perform_test (\&test_delete_present, $key, $keys, $description);
perform_test (\&test_store, $key, $keys, $description, [a=>'cheat']);
perform_test (\&test_store, $key, $keys, $description, []);
perform_test (\&test_absent, $lckey, $keys, $description);
perform_test (\&test_fetch_absent, $lckey, $keys, $description);
perform_test (\&test_delete_absent, $lckey, $keys, $description);
return if $unikey eq $key;
perform_test (\&test_absent, $unikey, $keys, $description);
perform_test (\&test_fetch_absent, $unikey, $keys, $description);
perform_test (\&test_delete_absent, $unikey, $keys, $description);
}
sub perform_test {
my ($test_sub, $key, $keys, $message, @other) = @_;
my $printable = join ',', map {ord} split //, $key;
my (%hash, %tiehash);
tie %tiehash, 'Tie::StdHash';
@hash{@$keys} = @$keys;
@tiehash{@$keys} = @$keys;
&$test_sub (\%hash, $key, $printable, $message, @other);
&$test_sub (\%tiehash, $key, $printable, "$message tie", @other);
}
sub test_present {
my ($hash, $key, $printable, $message) = @_;
ok (exists $hash->{$key}, "hv_exists_ent present$message $printable");
ok (XS::APItest::Hash::exists ($hash, $key),
"hv_exists present$message $printable");
}
sub test_absent {
my ($hash, $key, $printable, $message) = @_;
ok (!exists $hash->{$key}, "hv_exists_ent absent$message $printable");
ok (!XS::APItest::Hash::exists ($hash, $key),
"hv_exists absent$message $printable");
}
sub test_delete_present {
my ($hash, $key, $printable, $message) = @_;
my $copy = {};
my $class = tied %$hash;
if (defined $class) {
tie %$copy, ref $class;
}
$copy = {%$hash};
ok (brute_force_exists ($copy, $key),
"hv_delete_ent present$message $printable");
is (delete $copy->{$key}, $key, "hv_delete_ent present$message $printable");
ok (!brute_force_exists ($copy, $key),
"hv_delete_ent present$message $printable");
$copy = {%$hash};
ok (brute_force_exists ($copy, $key),
"hv_delete present$message $printable");
is (XS::APItest::Hash::delete ($copy, $key), $key,
"hv_delete present$message $printable");
ok (!brute_force_exists ($copy, $key),
"hv_delete present$message $printable");
}
sub test_delete_absent {
my ($hash, $key, $printable, $message) = @_;
my $copy = {};
my $class = tied %$hash;
if (defined $class) {
tie %$copy, ref $class;
}
$copy = {%$hash};
is (delete $copy->{$key}, undef, "hv_delete_ent absent$message $printable");
$copy = {%$hash};
is (XS::APItest::Hash::delete ($copy, $key), undef,
"hv_delete absent$message $printable");
}
sub test_store {
my ($hash, $key, $printable, $message, $defaults) = @_;
my $HV_STORE_IS_CRAZY = 1;
# We are cheating - hv_store returns NULL for a store into an empty
# tied hash. This isn't helpful here.
my $class = tied %$hash;
my %h1 = @$defaults;
my %h2 = @$defaults;
if (defined $class) {
tie %h1, ref $class;
tie %h2, ref $class;
$HV_STORE_IS_CRAZY = undef unless @$defaults;
}
is (XS::APItest::Hash::store_ent(\%h1, $key, 1), 1,
"hv_store_ent$message $printable");
ok (brute_force_exists (\%h1, $key), "hv_store_ent$message $printable");
is (XS::APItest::Hash::store(\%h2, $key, 1), $HV_STORE_IS_CRAZY,
"hv_store$message $printable");
ok (brute_force_exists (\%h2, $key), "hv_store$message $printable");
}
sub test_fetch_present {
my ($hash, $key, $printable, $message) = @_;
is ($hash->{$key}, $key, "hv_fetch_ent present$message $printable");
is (XS::APItest::Hash::fetch ($hash, $key), $key,
"hv_fetch present$message $printable");
}
sub test_fetch_absent {
my ($hash, $key, $printable, $message) = @_;
is ($hash->{$key}, undef, "hv_fetch_ent absent$message $printable");
is (XS::APItest::Hash::fetch ($hash, $key), undef,
"hv_fetch absent$message $printable");
}
sub brute_force_exists {
my ($hash, $key) = @_;
foreach (keys %$hash) {
return 1 if $key eq $_;
}
return 0;
}
--- NEW FILE: call.t ---
#!perl -w
# test the various call-into-perl-from-C functions
# DAPM Aug 2004
BEGIN {
chdir 't' if -d 't';
@INC = '../lib';
push @INC, "::lib:$MacPerl::Architecture:" if $^O eq 'MacOS';
require Config; import Config;
if ($Config{'extensions'} !~ /\bXS\/APItest\b/) {
# Look, I'm using this fully-qualified variable more than once!
my $arch = $MacPerl::Architecture;
print "1..0 # Skip: XS::APItest was not built\n";
exit 0;
}
}
use warnings;
use strict;
# Test::More doesn't have fresh_perl_is() yet
# use Test::More tests => 240;
BEGIN {
require './test.pl';
plan(240);
use_ok('XS::APItest')
};
#########################
sub f {
shift;
unshift @_, 'b';
pop @_;
@_, defined wantarray ? wantarray ? 'x' : 'y' : 'z';
}
sub d {
no warnings 'misc'; # keep G_KEEPERR from emitting this as a warning
die "its_dead_jim\n";
}
my $obj = bless [], 'Foo';
sub Foo::meth {
return 'bad_self' unless @_ && ref $_[0] && ref($_[0]) eq 'Foo';
shift;
shift;
unshift @_, 'b';
pop @_;
@_, defined wantarray ? wantarray ? 'x' : 'y' : 'z';
}
sub Foo::d {
no warnings 'misc'; # keep G_KEEPERR from emitting this as a warning
die "its_dead_jim\n";
}
for my $test (
# flags args expected description
[ G_VOID, [ ], [ qw(z 1) ], '0 args, G_VOID' ],
[ G_VOID, [ qw(a p q) ], [ qw(z 1) ], '3 args, G_VOID' ],
[ G_SCALAR, [ ], [ qw(y 1) ], '0 args, G_SCALAR' ],
[ G_SCALAR, [ qw(a p q) ], [ qw(y 1) ], '3 args, G_SCALAR' ],
[ G_ARRAY, [ ], [ qw(x 1) ], '0 args, G_ARRAY' ],
[ G_ARRAY, [ qw(a p q) ], [ qw(b p x 3) ], '3 args, G_ARRAY' ],
[ G_DISCARD, [ ], [ qw(0) ], '0 args, G_DISCARD' ],
[ G_DISCARD, [ qw(a p q) ], [ qw(0) ], '3 args, G_DISCARD' ],
)
{
my ($flags, $args, $expected, $description) = @$test;
ok(eq_array( [ call_sv(\&f, $flags, @$args) ], $expected),
"$description call_sv(\\&f)");
ok(eq_array( [ call_sv(*f, $flags, @$args) ], $expected),
"$description call_sv(*f)");
ok(eq_array( [ call_sv('f', $flags, @$args) ], $expected),
"$description call_sv('f')");
ok(eq_array( [ call_pv('f', $flags, @$args) ], $expected),
"$description call_pv('f')");
ok(eq_array( [ eval_sv('f(' . join(',',map"'$_'",@$args) . ')', $flags) ],
$expected), "$description eval_sv('f(args)')");
ok(eq_array( [ call_method('meth', $flags, $obj, @$args) ], $expected),
"$description call_method('meth')");
for my $keep (0, G_KEEPERR) {
my $desc = $description . ($keep ? ' G_KEEPERR' : '');
my $exp_err = $keep ? "before\n\t(in cleanup) its_dead_jim\n"
: "its_dead_jim\n";
$@ = "before\n";
ok(eq_array( [ call_sv('d', $flags|G_EVAL|$keep, @$args) ],
$flags & (G_ARRAY|G_DISCARD) ? [0] : [ undef, 1 ]),
"$desc G_EVAL call_sv('d')");
is($@, $exp_err, "$desc G_EVAL call_sv('d') - \$@");
$@ = "before\n";
ok(eq_array( [ call_pv('d', $flags|G_EVAL|$keep, @$args) ],
$flags & (G_ARRAY|G_DISCARD) ? [0] : [ undef, 1 ]),
"$desc G_EVAL call_pv('d')");
is($@, $exp_err, "$desc G_EVAL call_pv('d') - \$@");
$@ = "before\n";
ok(eq_array( [ eval_sv('d()', $flags|$keep) ],
$flags & (G_ARRAY|G_DISCARD) ? [0] : [ undef, 1 ]),
"$desc eval_sv('d()')");
is($@, $exp_err, "$desc eval_sv('d()') - \$@");
$@ = "before\n";
ok(eq_array( [ call_method('d', $flags|G_EVAL|$keep, $obj, @$args) ],
$flags & (G_ARRAY|G_DISCARD) ? [0] : [ undef, 1 ]),
"$desc G_EVAL call_method('d')");
is($@, $exp_err, "$desc G_EVAL call_method('d') - \$@");
}
ok(eq_array( [ sub { call_sv('f', $flags|G_NOARGS, "bad") }->(@$args) ],
$expected), "$description G_NOARGS call_sv('f')");
ok(eq_array( [ sub { call_pv('f', $flags|G_NOARGS, "bad") }->(@$args) ],
$expected), "$description G_NOARGS call_pv('f')");
ok(eq_array( [ sub { eval_sv('f(@_)', $flags|G_NOARGS) }->(@$args) ],
$expected), "$description G_NOARGS eval_sv('f(@_)')");
# XXX call_method(G_NOARGS) isn't tested: I'm assuming
# it's not a sensible combination. DAPM.
ok(eq_array( [ eval { call_sv('d', $flags, @$args)}, $@ ],
[ "its_dead_jim\n" ]), "$description eval { call_sv('d') }");
ok(eq_array( [ eval { call_pv('d', $flags, @$args) }, $@ ],
[ "its_dead_jim\n" ]), "$description eval { call_pv('d') }");
ok(eq_array( [ eval { eval_sv('d', $flags), $@ }, $@ ],
[ ($flags & (G_ARRAY|G_DISCARD)) ? (0) : (undef, 1),
"its_dead_jim\n", '' ]),
"$description eval { eval_sv('d') }");
ok(eq_array( [ eval { call_method('d', $flags, $obj, @$args) }, $@ ],
[ "its_dead_jim\n" ]), "$description eval { call_method('d') }");
};
is(eval_pv('f()', 0), 'y', "eval_pv('f()', 0)");
is(eval_pv('f(qw(a b c))', 0), 'y', "eval_pv('f(qw(a b c))', 0)");
is(eval_pv('d()', 0), undef, "eval_pv('d()', 0)");
is($@, "its_dead_jim\n", "eval_pv('d()', 0) - \$@");
is(eval { eval_pv('d()', 1) } , undef, "eval { eval_pv('d()', 1) }");
is($@, "its_dead_jim\n", "eval { eval_pv('d()', 1) } - \$@");
# DAPM 9-Aug-04. A taint test in eval_sv() could die after setting up
# a new jump level but before pushing an eval context, leading to
# stack corruption
fresh_perl_is(<<'EOF', "x=2", { switches => ['-T'] }, 'eval_sv() taint');
use XS::APItest;
my $x = 0;
sub f {
eval { my @a = ($^X . "x" , eval_sv(q(die "inner\n"), 0)) ; };
$x++;
$a <=> $b;
}
eval { my @a = sort f 2, 1; $x++};
print "x=$x\n";
EOF
--- NEW FILE: printf.t ---
BEGIN {
chdir 't' if -d 't';
@INC = '../lib';
push @INC, "::lib:$MacPerl::Architecture:" if $^O eq 'MacOS';
require Config; import Config;
if ($Config{'extensions'} !~ /\bXS\/APItest\b/) {
print "1..0 # Skip: XS::APItest was not built\n";
exit 0;
}
}
use Test::More tests => 11;
BEGIN { use_ok('XS::APItest') };
#########################
my $ldok = have_long_double();
# first some IO redirection
ok open(my $oldout, ">&STDOUT"), "saving STDOUT";
ok open(STDOUT, '>', "foo.out"),"redirecting STDOUT";
# Allow for it to be removed
END { unlink "foo.out"; };
select STDOUT; $| = 1; # make unbuffered
# Run the printf tests
print_double(5);
print_int(3);
print_long(4);
print_float(4);
print_long_double() if $ldok; # val=7 hardwired
print_flush();
# Now redirect STDOUT and read from the file
ok open(STDOUT, ">&", $oldout), "restore STDOUT";
ok open(my $foo, "<foo.out"), "open foo.out";
#print "# Test output by reading from file\n";
# now test the output
my @output = map { chomp; $_ } <$foo>;
close $foo;
ok @output >= 4, "captured at least four output lines";
is($output[0], "5.000", "print_double");
is($output[1], "3", "print_int");
is($output[2], "4", "print_long");
is($output[3], "4.000", "print_float");
SKIP: {
skip "No long doubles", 1 unless $ldok;
is($output[4], "7.000", "print_long_double");
}
--- NEW FILE: push.t ---
BEGIN {
chdir 't' if -d 't';
@INC = '../lib';
push @INC, "::lib:$MacPerl::Architecture:" if $^O eq 'MacOS';
require Config; import Config;
if ($Config{'extensions'} !~ /\bXS\/APItest\b/) {
print "1..0 # Skip: XS::APItest was not built\n";
exit 0;
}
}
use Test::More tests => 9;
BEGIN { use_ok('XS::APItest') };
#########################
my @mpushp = mpushp();
my @mpushn = mpushn();
my @mpushi = mpushi();
my @mpushu = mpushu();
ok(eq_array(\@mpushp, [qw(one two three)]), 'mPUSHp()');
ok(eq_array(\@mpushn, [0.5, -0.25, 0.125]), 'mPUSHn()');
ok(eq_array(\@mpushi, [-1, 2, -3]), 'mPUSHi()');
ok(eq_array(\@mpushu, [1, 2, 3]), 'mPUSHu()');
my @mxpushp = mxpushp();
my @mxpushn = mxpushn();
my @mxpushi = mxpushi();
my @mxpushu = mxpushu();
ok(eq_array(\@mxpushp, [qw(one two three)]), 'mXPUSHp()');
ok(eq_array(\@mxpushn, [0.5, -0.25, 0.125]), 'mXPUSHn()');
ok(eq_array(\@mxpushi, [-1, 2, -3]), 'mXPUSHi()');
ok(eq_array(\@mxpushu, [1, 2, 3]), 'mXPUSHu()');
More information about the dslinux-commit
mailing list