# total_size([]) will NOT return the size of the ref + the array, it will only
# return the size of the array alone!
-use Test::More tests => 16 + 4 *12;
+use Test::More;
use strict;
use Devel::Size ':all';
+my %types = (
+ NULL => undef,
+ IV => 42,
+ RV => \1,
+ NV => 3.14,
+ PV => "Perl rocks",
+ PVIV => do { my $a = 1; $a = "One"; $a },
+ PVNV => do { my $a = 3.14; $a = "Mmm, pi"; $a },
+ PVMG => do { my $a = $!; $a = "Bang!"; $a },
+);
+
+plan(tests => 20 + 4 * 12 + 2 * scalar keys %types);
+
#############################################################################
# verify that pointer sizes in array slots are sensible:
# create an array with 4 slots, 2 of them used
#############################################################################
# assert hash and hash key size
+# Note, undef puts PL_sv_undef on perl's stack. Assigning to a hash or array
+# value is always copying, so { a => undef } has a value which is a fresh
+# (allocated) SVt_NULL. Nowever, total_size(undef) isn't a copy, so total_size()
+# sees PL_sv_undef, which is a singleton, interpreter wide, so isn't counted as
+# part of the size. So we need to use an unassigned scalar to get the correct
+# size for a SVt_NULL:
+my $undef;
+
my $hash = {};
$hash->{a} = 1;
is (total_size($hash),
- total_size( { a => undef } ) + total_size(1) - total_size(undef),
+ total_size( { a => undef } ) + total_size(1) - total_size($undef),
'assert hash and hash key size');
#############################################################################
$array = [ 0..$size, undef, undef ]; pop @$array;
$array_size = total_size($array);
- my $scalar_size = total_size(1) * (1+$size) + total_size(undef) * 1 + $ptr_size
+ my $scalar_size = total_size(1) * (1+$size) + total_size($undef) * 1 + $ptr_size
+ $ptr_size * ($size + 2) + total_size([]);
is ($scalar_size, $array_size, "computed right size if full array");
cmp_array_ro(\@array, \@copy, 'two arrays compare the same');
}
+
+{
+ my %sizes;
+ # reverse sort ensures that PVIV, PVNV and RV are processed before
+ # IV, NULL, or NV :-)
+ foreach my $type (reverse sort keys %types) {
+ # Need to make sure this goes in a new scalar every time. Putting it
+ # directly in a lexical means that it's in the pad, and the pad recycles
+ # scalars, a side effect of which is that they get upgraded in ways we
+ # don't really want
+ my $a;
+ $a->[0] = $types{$type};
+ undef $a->[0];
+
+ my $expect = $sizes{$type} = size(\$a->[0]);
+
+ $a->[0] = \('x' x 1024);
+
+ $expect = $sizes{RV} if $type eq 'NULL';
+ $expect = $sizes{PVNV} if $type eq 'NV';
+ $expect = $sizes{PVIV} if $type eq 'IV' && $] < 5.012;
+
+ # Remember, size() removes a level of referencing if present. So add
+ # one, so that we get the size of our reference:
+ is(size(\$a->[0]), $expect,
+ "Type $type containing a reference, size() does not recurse to the referent");
+ cmp_ok(total_size(\$a->[0]), '>', 1024,
+ "Type $type, total_size() recurses to the referent");
+ }
+}
+
+{
+ my $sub_size = total_size(\&cmp_array_ro);
+ cmp_ok($sub_size, '>=', 5120, 'subroutine is at least 5K');
+ cmp_ok($sub_size, '<=', 51200, 'subroutine is no more than 50K')
+ or diag 'Is total_size() dragging in the entire symbol table?';
+ cmp_ok(total_size(\%::), '>=', 10240, 'symbol table is at least 100K');
+}
+
+cmp_ok(total_size(\%Exporter::), '>', total_size(\%Exporter::Heavy::));