Bug #43855 for Test-Weaken: suggest object contents callback

I got to this for a "contents" option test file. The idea would be for the contents function to run in array context so it can return multiple values. In the "moredata" leak case it and its sub-array would make an unfreed_count of 2, I think (exercising recursion into the contents returns).

#!/usr/bin/perl # MyObject has data hidden away from Test::Weaken's normal traversals, in # this case separate %data and %moredata hashes like an "inside-out" object, # or lik you sometimes have to do for extra data in a subclass, or even like # kept only in C code structures. package MyObject; use strict; use warnings; my %data; my %moredata; sub new { my ($class) = @_; my $scalar = 'this is a myobject'; my $self = bless \$scalar, $class; $data{$self+0} = [ 'extra data' ]; $moredata{$self+0} = [ 'more extra data', [ 'with a sub-array too' ] ]; return $self; } sub DESTROY { my ($self) = @_; delete $data{$self+0}; delete $moredata{$self+0}; } sub data { my ($self) = @_; return $data{$self+0}; } sub moredata { my ($self) = @_; return $data{$self+0}; } package main; use strict; use warnings; use Test::Weaken; use Test::More tests => 5; sub myobject_contest_func { my ($obj) = @_; return $obj->data, $obj->moredata; } { my $test = Test::Weaken::leaks ({ constructor => sub { return MyObject->new }, contents => \&myobject_contest_func }); is ($test, undef, 'good weaken of MyObject'); } { my $leak; my $test = Test::Weaken::leaks ({ constructor => sub { my $obj = return MyObject->new; $leak = $obj->data; return $obj; }, contents => \&myobject_contest_func, }); ok ($test, 'leaky "data" detection'); is ($test && $test->unfreed_count, 1, 'one object leaked'); } { my $leak; my $test = Test::Weaken::leaks ({ constructor => sub { my $obj = return MyObject->new; $leak = $obj->moredata; return $obj; }, contents => \&myobject_contest_func, }); ok ($test, 'leaky "moredata" detection'); is ($test && $test->unfreed_count, 2, 'one object leaked'); } exit 0;

I wrote: Show quoted text
I had a couple of stray "return"s which would prevent the supposed leaks from leaking!

#!/usr/bin/perl # MyObject has data hidden away from Test::Weaken's normal traversals, in # this case separate %data and %moredata hashes like an "inside-out" object, # or lik you sometimes have to do for extra data in a subclass, or even like # kept only in C code structures. package MyObject; use strict; use warnings; my %data; my %moredata; sub new { my ($class) = @_; my $scalar = 'this is a myobject'; my $self = bless \$scalar, $class; $data{$self+0} = [ 'extra data' ]; $moredata{$self+0} = [ 'more extra data', [ 'with a sub-array too' ] ]; return $self; } sub DESTROY { my ($self) = @_; delete $data{$self+0}; delete $moredata{$self+0}; } sub data { my ($self) = @_; return $data{$self+0}; } sub moredata { my ($self) = @_; return $data{$self+0}; } package main; use strict; use warnings; use Test::Weaken; use Test::More tests => 5; sub myobject_contest_func { my ($obj) = @_; return $obj->data, $obj->moredata; } { my $test = Test::Weaken::leaks ({ constructor => sub { return MyObject->new }, contents => \&myobject_contest_func }); is ($test, undef, 'good weaken of MyObject'); } { my $leak; my $test = Test::Weaken::leaks ({ constructor => sub { my $obj = MyObject->new; $leak = $obj->data; return $obj; }, contents => \&myobject_contest_func, }); ok ($test, 'leaky "data" detection'); is ($test && $test->unfreed_count, 1, 'one object leaked'); } { my $leak; my $test = Test::Weaken::leaks ({ constructor => sub { my $obj = MyObject->new; $leak = $obj->moredata; return $obj; }, contents => \&myobject_contest_func, }); ok ($test, 'leaky "moredata" detection'); is ($test && $test->unfreed_count, 2, 'one object leaked'); } exit 0;

"Jeffrey Kegler via RT" <bug-Test-Weaken@rt.cpan.org> writes: Show quoted text
The double indirection on the contents is not what I wanted please. I'd like it to callback on the objects themselves, not merely on scalars in the tree which refer to them -- per below. As motivation, returning contents based on the scalars is a bit wasteful, as it's quite likely several scalars will refer to the object, but you only really want to report extra contents just once against the object. (I suspect there may be something fishy in the code with objects which are scalar refs, and I'm pretty sure globs deserve callbacks so filehandle objects can be equal citizens, but starting with arrays and hashes will do what I'm interested in.)