File Hash-AutoHash-1.12_Build_n_Test.patch of Package perl-Hash-AutoHash

Overview Repositories Revisions Requests Users Attributes Meta

File Hash-AutoHash-1.12_Build_n_Test.patch of Package perl-Hash-AutoHash (Revision 819d5002523db998489c6b86e667b8b7)

Currently displaying revision 819d5002523db998489c6b86e667b8b7 , Show latest

diff -ruN Hash-AutoHash-1.12-orig/Build.PL Hash-AutoHash-1.12/Build.PL
--- Hash-AutoHash-1.12-orig/Build.PL	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/Build.PL	2010-07-28 15:12:17.000000000 +0200
@@ -39,7 +39,7 @@
    license             => 'perl',
    dist_author         => q{Nat Goodman <natg@shore.net>},
    dist_version_from   => 'lib/Hash/AutoHash.pm',
-   build_requires => {'Test::More' => 0.88,
+   build_requires => {'Test::More' => 0,
 		      'Test::Deep' => 0,
 		      'Exporter' => 0,
 		      'Tie::Hash::MultiValue' => 0,
diff -ruN Hash-AutoHash-1.12-orig/lib/Hash/AutoHash.pm Hash-AutoHash-1.12/lib/Hash/AutoHash.pm
--- Hash-AutoHash-1.12-orig/lib/Hash/AutoHash.pm	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/lib/Hash/AutoHash.pm	2010-07-28 15:23:33.000000000 +0200
@@ -299,7 +299,7 @@
     return $export_sym if defined *{$export_sym}{CODE};
     # see if ancestor renames it
     my($class)=$export_class=~/^(.*)::helper$/;
-    my $export_sym=${$class.'::EXPORT_OK'}{$func};
+    $export_sym=${$class.'::EXPORT_OK'}{$func};
     return $export_sym if defined $export_sym;
   }
   undef;
diff -ruN Hash-AutoHash-1.12-orig/META.yml Hash-AutoHash-1.12/META.yml
--- Hash-AutoHash-1.12-orig/META.yml	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/META.yml	2010-07-28 15:12:45.000000000 +0200
@@ -10,7 +10,7 @@
 build_requires:
   Exporter: 0
   Test::Deep: 0
-  Test::More: 0.88
+  Test::More: 0
   Tie::Hash::MultiValue: 0
 requires:
   Carp: 0
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.000.code_exists.t Hash-AutoHash-1.12/t/autohash.000.code_exists.t
--- Hash-AutoHash-1.12-orig/t/autohash.000.code_exists.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.000.code_exists.t	2010-07-28 15:20:28.000000000 +0200
@@ -9,4 +9,4 @@
   use_ok('autohashUtil');
 }
 diag( "Testing Hash::AutoHash $Hash::AutoHash::VERSION, Perl $], $^X" );
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.001.boilerplate.t Hash-AutoHash-1.12/t/autohash.001.boilerplate.t
--- Hash-AutoHash-1.12-orig/t/autohash.001.boilerplate.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.001.boilerplate.t	2010-07-28 15:20:28.000000000 +0200
@@ -2,7 +2,7 @@
 
 use strict;
 use warnings;
-use Test::More tests => 3;
+use Test::More qw(no_plan);
 use Hash::AutoHash;
 
 sub not_in_file_ok {
@@ -50,7 +50,7 @@
 	      );
 
 module_boilerplate_ok('lib/Hash/AutoHash.pm');
-done_testing();
+#done_testing();
 
 
 # }
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.002.pod.t Hash-AutoHash-1.12/t/autohash.002.pod.t
--- Hash-AutoHash-1.12-orig/t/autohash.002.pod.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.002.pod.t	2010-07-28 15:22:35.000000000 +0200
@@ -11,4 +11,4 @@
 plan skip_all => "Test::Pod $min_tp required for testing POD" if $@;
 
 all_pod_files_ok();
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.010.cons_funcs.t Hash-AutoHash-1.12/t/autohash.010.cons_funcs.t
--- Hash-AutoHash-1.12-orig/t/autohash.010.cons_funcs.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.010.cons_funcs.t	2010-07-28 15:26:55.000000000 +0200
@@ -4,7 +4,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::Deep;
 use autohashUtil;
 require 'autohash.01x.constructors.pm';
@@ -18,44 +18,44 @@
 $autohash=autohash_hash;
 cmp_types($label);
 test_autohash($label,0,@VALUES_SV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_hash (key1=>'value11',key2=>'value21');
 cmp_types($label);
 test_autohash($label,1,@VALUES_SV);
 
 # autohash_tie
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_tie';
-my $label="$constructor without initial values";
+$constructor='autohash_tie';
+$label="$constructor without initial values";
 $autohash=autohash_tie TieMV;
 cmp_types($label,'TieMV');
 test_autohash($label,0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_tie TieMV,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV');
 test_autohash($label,1,@VALUES_MV);
 
 # autohash_wrap (real)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wrap (real)';
-my $label="$constructor without initial values";
+$constructor='autohash_wrap (real)';
+$label="$constructor without initial values";
 $autohash=autohash_wrap %hash;
 cmp_types($label,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,0,@VALUES_SV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_wrap %hash,(key1=>'value11',key2=>'value21');
 cmp_types($label,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,1,@VALUES_SV);
 
 # autohash_wrap (tied)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wrap (tied)';
-my $label="$constructor without initial values";
+$constructor='autohash_wrap (tied)';
+$label="$constructor without initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrap %hash;
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrap %hash,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV','TieMV','TieMV','TieMV');
@@ -63,13 +63,13 @@
 
 # autohash_wrapobj
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wrapobj';
-my $label="$constructor without initial values";
+$constructor='autohash_wrapobj';
+$label="$constructor without initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrapobj $object;
 cmp_types($label,'TieMV','TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrapobj $object,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV','TieMV','TieMV','TieMV');
@@ -78,16 +78,16 @@
 
 # autohash_wraptie
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wraptie';
-my $label="$constructor without initial values";
+$constructor='autohash_wraptie';
+$label="$constructor without initial values";
 $autohash=autohash_wraptie %hash,TieMV;
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_wraptie %hash,TieMV,(key1=>'value11',key2=>'value21');
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',1,@VALUES_MV);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.011.new_func.t Hash-AutoHash-1.12/t/autohash.011.new_func.t
--- Hash-AutoHash-1.12-orig/t/autohash.011.new_func.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.011.new_func.t	2010-07-28 17:40:02.000000000 +0200
@@ -4,7 +4,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::Deep;
 use autohashUtil;
 require 'autohash.01x.constructors.pm';
@@ -18,33 +18,33 @@
 $autohash=autohash_new;
 cmp_types($label);
 test_autohash($label,0,@VALUES_SV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_new (key1=>'value11',key2=>'value21');
 cmp_types($label);
 test_autohash($label,1,@VALUES_SV);
 
 # autohash_new (tie)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_new (tie)';
-my $label="$constructor without initial values";
+$constructor='autohash_new (tie)';
+$label="$constructor without initial values";
 $autohash=autohash_new ['TieMV'];
 cmp_types($label,'TieMV');
 test_autohash($label,0,@VALUES_MV);
-my $label="$constructor with TIEHASH param and no initial values";
+$label="$constructor with TIEHASH param and no initial values";
 is($TieMV::TIEHASH_PARAM,undef,"$label: TIEHASH param before test");
 $autohash=autohash_new ['TieMV','tiehash_param1'];
 cmp_types($label,'TieMV');
 is($TieMV::TIEHASH_PARAM,'tiehash_param1',"$label: TIEHASH param");
 test_autohash($label,0,@VALUES_MV);
-my $label="$constructor with initial values passed to TIEHASH";
+$label="$constructor with initial values passed to TIEHASH";
 $autohash=autohash_new ['TieMV',(key1=>'value11',key2=>'value21')];
 cmp_types($label,'TieMV');
 test_autohash($label,1,@VALUES_MV);
-my $label="$constructor with initial values set by autohash_new";
+$label="$constructor with initial values set by autohash_new";
 $autohash=autohash_new ['TieMV'],(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV');
 test_autohash($label,1,@VALUES_MV);
-my $label="$constructor with TIEHASH param and initial values set by autohash_new";
+$label="$constructor with TIEHASH param and initial values set by autohash_new";
 $autohash=autohash_new ['TieMV','tiehash_param2'],(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV');
 is($TieMV::TIEHASH_PARAM,'tiehash_param2',"$label: TIEHASH param");
@@ -52,25 +52,25 @@
 
 # autohash_new (wrap real)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_new (wrap real)';
-my $label="$constructor without initial values";
+$constructor='autohash_new (wrap real)';
+$label="$constructor without initial values";
 $autohash=autohash_new \%hash;
 cmp_types($label,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,0,@VALUES_SV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_new \%hash,(key1=>'value11',key2=>'value21');
 cmp_types($label,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,1,@VALUES_SV);
 
 # autohash_new (wrap tied)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_new (wrap tied)';
-my $label="$constructor without initial values";
+$constructor='autohash_new (wrap tied)';
+$label="$constructor without initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_new \%hash;
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_new \%hash,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV','TieMV','TieMV');
@@ -78,13 +78,13 @@
 
 # autohash_new (wrap object)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_new (wrap object)';
-my $label="$constructor without initial values";
+$constructor='autohash_new (wrap object)';
+$label="$constructor without initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_new $object;
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_new $object,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV','TieMV','TieMV');
@@ -93,13 +93,13 @@
 
 # autohash_new (wraptie)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_new (wraptie)';
-my $label="$constructor without initial values";
+$constructor='autohash_new (wraptie)';
+$label="$constructor without initial values";
 $autohash=autohash_new [\%hash,'TieMV'];
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with TIEHASH param and no initial values";
+$label="$constructor with TIEHASH param and no initial values";
 $TieMV::TIEHASH_PARAM=undef;
 is($TieMV::TIEHASH_PARAM,undef,"$label: TIEHASH param before test");
 $autohash=autohash_new [\%hash,'TieMV','tiehash_param1'];
@@ -107,21 +107,21 @@
 cmp_types($label,'TieMV','TieMV','TieMV');
 is($TieMV::TIEHASH_PARAM,'tiehash_param1',"$label: TIEHASH param");
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values passed to TIEHASH";
+$label="$constructor with initial values passed to TIEHASH";
 $autohash=autohash_new [\%hash,'TieMV',(key1=>'value11',key2=>'value21')];
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',1,@VALUES_MV);
-my $label="$constructor with initial values set by autohash_new";
+$label="$constructor with initial values set by autohash_new";
 $autohash=autohash_new [\%hash,'TieMV'],(key1=>'value11',key2=>'value21');
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',1,@VALUES_MV);
-my $label="$constructor with TIEHASH param and initial values set by autohash_new";
+$label="$constructor with TIEHASH param and initial values set by autohash_new";
 $autohash=autohash_new [\%hash,'TieMV','tiehash_param2'],(key1=>'value11',key2=>'value21');
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 is($TieMV::TIEHASH_PARAM,'tiehash_param2',"$label: TIEHASH param");
 test_autohash_more($label,'hash','object',1,@VALUES_MV);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.012.new_method.t Hash-AutoHash-1.12/t/autohash.012.new_method.t
--- Hash-AutoHash-1.12-orig/t/autohash.012.new_method.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.012.new_method.t	2010-07-28 15:43:36.000000000 +0200
@@ -4,7 +4,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::More qw/no_plan/;
 # use Test::Deep;
 use autohashUtil;
@@ -19,44 +19,44 @@
 $autohash=new Hash::AutoHash;
 cmp_types($label);
 test_autohash($label,0,@VALUES_SV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=new Hash::AutoHash (key1=>'value11',key2=>'value21');
 cmp_types($label);
 test_autohash($label,1,@VALUES_SV);
 
 # new Hash::AutoHash (tie)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='new Hash::AutoHash (tie)';
-my $label="$constructor without initial values";
+$constructor='new Hash::AutoHash (tie)';
+$label="$constructor without initial values";
 $autohash=new Hash::AutoHash ['TieMV'];
 cmp_types($label,'TieMV');
 test_autohash($label,0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=new Hash::AutoHash ['TieMV',(key1=>'value11',key2=>'value21')];
 cmp_types($label,'TieMV');
 test_autohash($label,1,@VALUES_MV);
 
 # new Hash::AutoHash (wrap real)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='new Hash::AutoHash (wrap real)';
-my $label="$constructor without initial values";
+$constructor='new Hash::AutoHash (wrap real)';
+$label="$constructor without initial values";
 $autohash=new Hash::AutoHash \%hash;
 cmp_types($label,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,0,@VALUES_SV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=new Hash::AutoHash \%hash,(key1=>'value11',key2=>'value21');
 cmp_types($label,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,1,@VALUES_SV);
 
 # new Hash::AutoHash (wrap tied)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='new Hash::AutoHash (wrap tied)';
-my $label="$constructor without initial values";
+$constructor='new Hash::AutoHash (wrap tied)';
+$label="$constructor without initial values";
 $object=tie %hash,'TieMV';
 $autohash=new Hash::AutoHash \%hash;
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 $autohash=new Hash::AutoHash \%hash,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV','TieMV','TieMV');
@@ -64,13 +64,13 @@
 
 # new Hash::AutoHash (wrap object)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='new Hash::AutoHash (wrap object)';
-my $label="$constructor without initial values";
+$constructor='new Hash::AutoHash (wrap object)';
+$label="$constructor without initial values";
 $object=tie %hash,'TieMV';
 $autohash=new Hash::AutoHash $object;
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 $autohash=new Hash::AutoHash $object,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV','TieMV','TieMV');
@@ -79,16 +79,16 @@
 
 # new Hash::AutoHash (wraptie)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='new Hash::AutoHash (wraptie)';
-my $label="$constructor without initial values";
+$constructor='new Hash::AutoHash (wraptie)';
+$label="$constructor without initial values";
 $autohash=new Hash::AutoHash [\%hash,'TieMV'];
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=new Hash::AutoHash [\%hash,'TieMV',(key1=>'value11',key2=>'value21')];
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',1,@VALUES_MV);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.013.ashash.t Hash-AutoHash-1.12/t/autohash.013.ashash.t
--- Hash-AutoHash-1.12-orig/t/autohash.013.ashash.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.013.ashash.t	2010-07-28 15:44:34.000000000 +0200
@@ -4,7 +4,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::More qw/no_plan/;
 # use Test::Deep;
 use autohashUtil;
@@ -19,44 +19,44 @@
 $autohash=autohash_hash;
 cmp_types($label);
 test_ashash($label,0,@VALUES_SV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_hash (key1=>'value11',key2=>'value21');
 cmp_types($label);
 test_ashash($label,1,@VALUES_SV);
 
 # autohash_tie
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_tie';
-my $label="$constructor without initial values";
+$constructor='autohash_tie';
+$label="$constructor without initial values";
 $autohash=autohash_tie TieMV;
 cmp_types($label,'TieMV');
 test_ashash($label,0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_tie TieMV,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV');
 test_ashash($label,1,@VALUES_MV);
 
 # autohash_wrap (real)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wrap (real)';
-my $label="$constructor without initial values";
+$constructor='autohash_wrap (real)';
+$label="$constructor without initial values";
 $autohash=autohash_wrap %hash;
 cmp_types($label,'Hash::AutoHash::alias');
 test_ashash_more($label,'hash',undef,0,@VALUES_SV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_wrap %hash,(key1=>'value11',key2=>'value21');
 cmp_types($label,'Hash::AutoHash::alias');
 test_ashash_more($label,'hash',undef,1,@VALUES_SV);
 
 # autohash_wrap (tied)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wrap (tied)';
-my $label="$constructor without initial values";
+$constructor='autohash_wrap (tied)';
+$label="$constructor without initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrap %hash;
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_ashash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrap %hash,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV','TieMV','TieMV');
@@ -64,13 +64,13 @@
 
 # autohash_wrapobj
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wrapobj';
-my $label="$constructor without initial values";
+$constructor='autohash_wrapobj';
+$label="$constructor without initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrapobj $object;
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_ashash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrapobj $object,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV','TieMV','TieMV');
@@ -78,16 +78,16 @@
 
 # autohash_wraptie
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wraptie';
-my $label="$constructor without initial values";
+$constructor='autohash_wraptie';
+$label="$constructor without initial values";
 $autohash=autohash_wraptie %hash,TieMV;
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_ashash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_wraptie %hash,TieMV,(key1=>'value11',key2=>'value21');
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_ashash_more($label,'hash','object',1,@VALUES_MV);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.013.exthash.t Hash-AutoHash-1.12/t/autohash.013.exthash.t
--- Hash-AutoHash-1.12-orig/t/autohash.013.exthash.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.013.exthash.t	2010-07-28 15:45:08.000000000 +0200
@@ -4,7 +4,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::More qw/no_plan/;
 # use Test::Deep;
 use autohashUtil;
@@ -19,20 +19,20 @@
 $autohash=autohash_wrap %hash;
 cmp_types($label,'Hash::AutoHash::alias');
 test_exthash_more($label,'hash',undef,0,@VALUES_SV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_wrap %hash,(key1=>'value11',key2=>'value21');
 cmp_types($label,'Hash::AutoHash::alias');
 test_exthash_more($label,'hash',undef,1,@VALUES_SV);
 
 # autohash_wrap (tied)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wrap (tied)';
-my $label="$constructor without initial values";
+$constructor='autohash_wrap (tied)';
+$label="$constructor without initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrap %hash;
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_exthash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrap %hash,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV','TieMV','TieMV');
@@ -40,13 +40,13 @@
 
 # autohash_wrapobj
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wrapobj';
-my $label="$constructor without initial values";
+$constructor='autohash_wrapobj';
+$label="$constructor without initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrapobj $object;
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_exthash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrapobj $object,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV','TieMV','TieMV');
@@ -54,16 +54,16 @@
 
 # autohash_wraptie
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wraptie';
-my $label="$constructor without initial values";
+$constructor='autohash_wraptie';
+$label="$constructor without initial values";
 $autohash=autohash_wraptie %hash,TieMV;
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_exthash_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_wraptie %hash,TieMV,(key1=>'value11',key2=>'value21');
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_exthash_more($label,'hash','object',1,@VALUES_MV);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.013.extobj.t Hash-AutoHash-1.12/t/autohash.013.extobj.t
--- Hash-AutoHash-1.12-orig/t/autohash.013.extobj.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.013.extobj.t	2010-07-28 15:45:33.000000000 +0200
@@ -4,7 +4,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::More qw/no_plan/;
 # use Test::Deep;
 use autohashUtil;
@@ -20,7 +20,7 @@
 $autohash=autohash_wrap %hash;
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_extobj_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrap %hash,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV','TieMV','TieMV');
@@ -28,13 +28,13 @@
 
 # autohash_wrapobj
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wrapobj';
-my $label="$constructor without initial values";
+$constructor='autohash_wrapobj';
+$label="$constructor without initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrapobj $object;
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_extobj_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrapobj $object,(key1=>'value11',key2=>'value21');
 cmp_types($label,'TieMV','TieMV','TieMV');
@@ -42,16 +42,16 @@
 
 # autohash_wraptie
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wraptie';
-my $label="$constructor without initial values";
+$constructor='autohash_wraptie';
+$label="$constructor without initial values";
 $autohash=autohash_wraptie %hash,TieMV;
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_extobj_more($label,'hash','object',0,@VALUES_MV);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_wraptie %hash,TieMV,(key1=>'value11',key2=>'value21');
 $object=tied(%hash);
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_extobj_more($label,'hash','object',1,@VALUES_MV);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.019.export_ok.t Hash-AutoHash-1.12/t/autohash.019.export_ok.t
--- Hash-AutoHash-1.12-orig/t/autohash.019.export_ok.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.019.export_ok.t	2010-07-28 15:20:28.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 use Hash::AutoHash;
 # use autohashUtil;
@@ -24,4 +24,4 @@
 cmp_set(\@Hash::AutoHash::SUBCLASS_EXPORT_OK,\@subclass_export_ok,'@SUBCLASS_EXPORT_OK');
 cmp_deeply(\%Hash::AutoHash::EXPORT_OK,\%export_ok,'%EXPORT_OK');
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.020.class_methods.t Hash-AutoHash-1.12/t/autohash.020.class_methods.t
--- Hash-AutoHash-1.12-orig/t/autohash.020.class_methods.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.020.class_methods.t	2010-07-28 15:20:28.000000000 +0200
@@ -1,11 +1,11 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 use autohashUtil;
 use Hash::AutoHash;
 
 test_class_methods('Hash::AutoHash','autohash_set');
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.020.special_keys.t Hash-AutoHash-1.12/t/autohash.020.special_keys.t
--- Hash-AutoHash-1.12-orig/t/autohash.020.special_keys.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.020.special_keys.t	2010-07-28 15:46:49.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 use autohashUtil;
 require 'autohash.TieMV.pm';	# example tied hash class
@@ -18,8 +18,8 @@
   $autohash=autohash_tie TieMV;
   $autohash->$key($value);	# set value
   $autohash->$key($value);	# set value
-  my $actual=$autohash->$key;	# get value
-  my $correct=[$value,$value];
+  $actual=$autohash->$key;	# get value
+  $correct=[$value,$value];
   cmp_deeply($actual,$correct,"tied. key=$key");
 }
 
@@ -30,4 +30,4 @@
   test_special_keys($key,$value);
 }
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.030.alias.t Hash-AutoHash-1.12/t/autohash.030.alias.t
--- Hash-AutoHash-1.12-orig/t/autohash.030.alias.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.030.alias.t	2010-07-28 15:50:40.000000000 +0200
@@ -4,7 +4,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::More qw/no_plan/;
 # use Test::Deep;
 use autohashUtil;
@@ -22,107 +22,107 @@
 cmp_types($label,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,0,@VALUES_SV);
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_types($label,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,1,@VALUES_SV);
 
 # autohash_alias (wrap tied)
-my $constructor='autohash_alias (wrap tied)';
+$constructor='autohash_alias (wrap tied)';
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor without initial values";
+$label="$constructor without initial values";
 $object=tie %hash,'TieMV';
 autohash_alias $autohash,%hash;
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieMV';
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_types($label,'TieMV','TieMV','TieMV');
 test_autohash_more($label,'hash','object',1,@VALUES_MV);
 
 # autohash_hash
-my $constructor='autohash_alias autohash_hash';
+$constructor='autohash_alias autohash_hash';
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor without initial values";
+$label="$constructor without initial values";
 $autohash=autohash_hash;
 autohash_alias $autohash,%hash;
 cmp_types($label,undef,undef,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,0,@VALUES_SV);
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_hash (key1=>'value11',key2=>'value21');
 autohash_alias $autohash,%hash;
 cmp_types($label,undef,undef,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,1,@VALUES_SV);
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor alias with initial values";
+$label="$constructor alias with initial values";
 $autohash=autohash_hash;
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_types($label,undef,undef,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,1,@VALUES_SV);
 
 # autohash_tie
-my $constructor='autohash_alias autohash_tie';
+$constructor='autohash_alias autohash_tie';
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor without initial values";
+$label="$constructor without initial values";
 $autohash=autohash_tie TieMV;
 autohash_alias $autohash,%hash;
 cmp_types($label,'TieMV',undef,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,0,@VALUES_MV);
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_tie TieMV,(key1=>'value11',key2=>'value21');
 autohash_alias $autohash,%hash;
 cmp_types($label,'TieMV',undef,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,1,@VALUES_MV);
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor alias with initial values";
+$label="$constructor alias with initial values";
 $autohash=autohash_tie TieMV;
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_types($label,'TieMV',undef,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,1,@VALUES_MV);
 
 # autohash_wrap (real)
-my $constructor='autohash_alias autohash_wrap (real)';
+$constructor='autohash_alias autohash_wrap (real)';
 undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor without initial values";
+$label="$constructor without initial values";
 $autohash=autohash_wrap %source;
 autohash_alias $autohash,%hash;
 cmp_types($label,'Hash::AutoHash::alias',undef,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,0,@VALUES_SV);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor with initial values";
 $autohash=autohash_wrap %source,(key1=>'value11',key2=>'value21');
 autohash_alias $autohash,%hash;
 cmp_types($label,'Hash::AutoHash::alias',undef,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,1,@VALUES_SV);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor alias with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor alias with initial values";
 $autohash=autohash_wrap %source;
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_types($label,'Hash::AutoHash::alias',undef,'Hash::AutoHash::alias');
 test_autohash_more($label,'hash',undef,1,@VALUES_SV);
 
 # autohash_wrap (tied)
-my $constructor='autohash_alias autohash_wrap (tied)';
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor without initial values";
+$constructor='autohash_alias autohash_wrap (tied)';
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor without initial values";
 $object=tie %source,'TieMV';
 $autohash=autohash_wrap %source;
 autohash_alias $autohash,%hash;
 cmp_types($label,'TieMV','TieMV','Hash::AutoHash::alias');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor with initial values";
 $object=tie %source,'TieMV';
 $autohash=autohash_wrap %source,(key1=>'value11',key2=>'value21');
 autohash_alias $autohash,%hash;
 cmp_types($label,'TieMV','TieMV','Hash::AutoHash::alias');
 test_autohash_more($label,'hash','object',1,@VALUES_MV);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor alias with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor alias with initial values";
 $object=tie %source,'TieMV';
 $autohash=autohash_wrap %source;
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
@@ -130,23 +130,23 @@
 test_autohash_more($label,'hash','object',1,@VALUES_MV);
 
 # autohash_wrapobj
-my $constructor='autohash_alias autohash_wrapobj';
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor without initial values";
+$constructor='autohash_alias autohash_wrapobj';
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor without initial values";
 $object=tie %source,'TieMV';
 $autohash=autohash_wrapobj $object;
 autohash_alias $autohash,%hash;
 cmp_types($label,'TieMV','TieMV','Hash::AutoHash::alias');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor with initial values";
 $object=tie %source,'TieMV';
 $autohash=autohash_wrapobj $object,(key1=>'value11',key2=>'value21');
 autohash_alias $autohash,%hash;
 cmp_types($label,'TieMV','TieMV','Hash::AutoHash::alias');
 test_autohash_more($label,'hash','object',1,@VALUES_MV);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor alias with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor alias with initial values";
 $object=tie %source,'TieMV';
 $autohash=autohash_wrapobj $object;
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
@@ -154,27 +154,27 @@
 test_autohash_more($label,'hash','object',1,@VALUES_MV);
 
 # autohash_wraptie
-my $constructor='autohash_alias autohash_wraptie';
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor without initial values";
+$constructor='autohash_alias autohash_wraptie';
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor without initial values";
 $autohash=autohash_wraptie %source,TieMV;
 $object=tied(%source);
 autohash_alias $autohash,%hash;
 cmp_types($label,'TieMV','TieMV','Hash::AutoHash::alias');
 test_autohash_more($label,'hash','object',0,@VALUES_MV);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor with initial values";
 $autohash=autohash_wraptie %source,TieMV,(key1=>'value11',key2=>'value21');
 $object=tied(%source);
 autohash_alias $autohash,%hash;
 cmp_types($label,'TieMV','TieMV','Hash::AutoHash::alias');
 test_autohash_more($label,'hash','object',1,@VALUES_MV);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor alias with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor alias with initial values";
 $autohash=autohash_wraptie %source,TieMV;
 $object=tied(%source);
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_types($label,'TieMV','TieMV','Hash::AutoHash::alias');
 test_autohash_more($label,'hash','object',1,@VALUES_MV);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.030.clear.t Hash-AutoHash-1.12/t/autohash.030.clear.t
--- Hash-AutoHash-1.12-orig/t/autohash.030.clear.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.030.clear.t	2010-07-28 17:49:04.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::Deep;
 require 'autohash.TieMV.pm';	# example tied hash class
 use autohashUtil;
@@ -28,34 +28,34 @@
 autohash_clear($autohash);
 ok_autohash_empty("$constructor after clear");
 
-my $constructor='autohash_new (tie)';
+$constructor='autohash_new (tie)';
 $autohash=autohash_new ['TieMV'],@INITIAL_VALUES;
 cmp_autohash("$constructor before clear:",$VALUES_MV[1]);
 autohash_clear($autohash);
 ok_autohash_empty("$constructor after clear");
 
-my $constructor='autohash_new (wrap real)';
+$constructor='autohash_new (wrap real)';
 undef %hash;
 $autohash=autohash_new \%hash,@INITIAL_VALUES;
 cmp_autohash("$constructor before clear:",$VALUES_SV[1],'hash',undef);
 autohash_clear($autohash);
 ok_autohash_empty("$constructor after clear",'hash');
 
-my $constructor='autohash_new (wrap tied)';
+$constructor='autohash_new (wrap tied)';
 $object=tie %hash,'TieMV';
 $autohash=autohash_new \%hash,@INITIAL_VALUES;
 cmp_autohash("$constructor before clear:",$VALUES_MV[1],'hash','object');
 autohash_clear($autohash);
 ok_autohash_empty("$constructor after clear",'hash','object');
 
-my $constructor='autohash_new (wrap object)';
+$constructor='autohash_new (wrap object)';
 $object=tie %hash,'TieMV';
 $autohash=autohash_new $object,@INITIAL_VALUES;
 cmp_autohash("$constructor before clear:",$VALUES_MV[1],'hash','object');
 autohash_clear($autohash);
 ok_autohash_empty("$constructor after clear",'hash','object');
 
-my $constructor='autohash_new (wraptie)';
+$constructor='autohash_new (wraptie)';
 my $label="$constructor without initial values";
 $autohash=autohash_new [\%hash,'TieMV'],@INITIAL_VALUES;
 $object=tied(%hash);
@@ -65,43 +65,43 @@
 
 undef $autohash; undef $object; untie %hash; undef %hash;
 
-my $constructor='autohash_hash';
+$constructor='autohash_hash';
 $autohash=autohash_hash @INITIAL_VALUES;
 cmp_autohash("$constructor before clear:",$VALUES_SV[1]);
 autohash_clear($autohash);
 ok_autohash_empty("$constructor after clear");
 
-my $constructor='autohash_tie';
+$constructor='autohash_tie';
 $autohash=autohash_tie TieMV,@INITIAL_VALUES;
 cmp_autohash("$constructor before clear:",$VALUES_MV[1]);
 autohash_clear($autohash);
 ok_autohash_empty("$constructor after clear");
 
-my $constructor='autohash_wrap (real)';
+$constructor='autohash_wrap (real)';
 $autohash=autohash_wrap %hash,@INITIAL_VALUES;
 cmp_autohash("$constructor before clear:",$VALUES_SV[1],'hash',undef);
 autohash_clear($autohash);
 ok_autohash_empty("$constructor after clear",'hash');
 
-my $constructor='autohash_wrap (tied)';
+$constructor='autohash_wrap (tied)';
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrap %hash,@INITIAL_VALUES;
 cmp_autohash("$constructor before clear:",$VALUES_MV[1],'hash','object');
 autohash_clear($autohash);
 ok_autohash_empty("$constructor after clear",'hash','object');
 
-my $constructor='autohash_wrapobj';
+$constructor='autohash_wrapobj';
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrapobj $object,@INITIAL_VALUES;
 cmp_autohash("$constructor before clear:",$VALUES_MV[1],'hash','object');
 autohash_clear($autohash);
 ok_autohash_empty("$constructor after clear",'hash','object');
 
-my $constructor='autohash_wraptie';
+$constructor='autohash_wraptie';
 $autohash=autohash_wraptie %hash,TieMV,@INITIAL_VALUES;
 $object=tied(%hash);
 cmp_autohash("$constructor before clear:",$VALUES_MV[1],'hash','object');
 autohash_clear($autohash);
 ok_autohash_empty("$constructor after clear",'hash','object');
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.030.count_etc.t Hash-AutoHash-1.12/t/autohash.030.count_etc.t
--- Hash-AutoHash-1.12-orig/t/autohash.030.count_etc.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.030.count_etc.t	2010-07-28 15:55:16.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::Deep;
 require 'autohash.TieMV.pm';	# example tied hash class
 use autohashUtil;
@@ -29,34 +29,34 @@
 $autohash=autohash_new @INITIAL_VALUES;
 test_count_etc($constructor,2);
 
-my $constructor='autohash_new (tie)';
+$constructor='autohash_new (tie)';
 $autohash=autohash_new ['TieMV'];
 test_count_etc($constructor,0);
 $autohash=autohash_new ['TieMV'],@INITIAL_VALUES;
 test_count_etc($constructor,2);
 
-my $constructor='autohash_new (wrap real)';
+$constructor='autohash_new (wrap real)';
 undef %hash;
 $autohash=autohash_new \%hash;
 test_count_etc($constructor,0,'hash');
 $autohash=autohash_new \%hash,@INITIAL_VALUES;
 test_count_etc($constructor,2,'hash');
 
-my $constructor='autohash_new (wrap tied)';
+$constructor='autohash_new (wrap tied)';
 $object=tie %hash,'TieMV';
 $autohash=autohash_new \%hash;
 test_count_etc($constructor,0,'hash','object');
 $autohash=autohash_new \%hash,@INITIAL_VALUES;
 test_count_etc($constructor,2,'hash','object');
 
-my $constructor='autohash_new (wrap object)';
+$constructor='autohash_new (wrap object)';
 $object=tie %hash,'TieMV';
 $autohash=autohash_new $object;
 test_count_etc($constructor,0,'hash','object');
 $autohash=autohash_new $object,@INITIAL_VALUES;
 test_count_etc($constructor,2,'hash','object');
 
-my $constructor='autohash_new (wraptie)';
+$constructor='autohash_new (wraptie)';
 $autohash=autohash_new [\%hash,'TieMV'];
 $object=tied(%hash);
 test_count_etc($constructor,0,'hash','object');
@@ -66,39 +66,39 @@
 
 undef $autohash; undef $object; untie %hash; undef %hash;
 
-my $constructor='autohash_hash';
+$constructor='autohash_hash';
 $autohash=autohash_hash;
 test_count_etc($constructor,0);
 $autohash=autohash_hash @INITIAL_VALUES;
 test_count_etc($constructor,2);
 
-my $constructor='autohash_tie';
+$constructor='autohash_tie';
 $autohash=autohash_tie TieMV;
 test_count_etc($constructor,0);
 $autohash=autohash_tie TieMV,@INITIAL_VALUES;
 test_count_etc($constructor,2);
 
-my $constructor='autohash_wrap (real)';
+$constructor='autohash_wrap (real)';
 $autohash=autohash_wrap %hash;
 test_count_etc($constructor,0,'hash');
 $autohash=autohash_wrap %hash,@INITIAL_VALUES;
 test_count_etc($constructor,2,'hash');
 
-my $constructor='autohash_wrap (tied)';
+$constructor='autohash_wrap (tied)';
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrap %hash;
 test_count_etc($constructor,0,'hash','object');
 $autohash=autohash_wrap %hash,@INITIAL_VALUES;
 test_count_etc($constructor,2,'hash','object');
 
-my $constructor='autohash_wrapobj';
+$constructor='autohash_wrapobj';
 $object=tie %hash,'TieMV';
 $autohash=autohash_wrapobj $object;
 test_count_etc($constructor,0,'hash','object');
 $autohash=autohash_wrapobj $object,@INITIAL_VALUES;
 test_count_etc($constructor,2,'hash','object');
 
-my $constructor='autohash_wraptie';
+$constructor='autohash_wraptie';
 $autohash=autohash_wraptie %hash,TieMV;
 $object=tied(%hash);
 test_count_etc($constructor,0,'hash','object');
@@ -106,4 +106,4 @@
 $object=tied(%hash);
 test_count_etc($constructor,2,'hash','object');
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.030.delete.t Hash-AutoHash-1.12/t/autohash.030.delete.t
--- Hash-AutoHash-1.12-orig/t/autohash.030.delete.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.030.delete.t	2010-07-28 18:08:16.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 require 'autohash.TieMV.pm';	# example tied hash class
 use autohashUtil;
@@ -74,7 +74,7 @@
     no strict 'refs';
     &$sub($constructor,$i,\%VALUES_SV);
   }}
-my $constructor='autohash_new (tie)';
+$constructor='autohash_new (tie)';
 for(my $i=0; $i<=3; $i++) {
   for my $test qw(func ashash) {
     undef $autohash; undef $object; untie %hash; undef %hash;
@@ -83,7 +83,7 @@
     no strict 'refs';
     &$sub($constructor,$i,\%VALUES_MV);
   }}
-my $constructor='autohash_new (wrap real)';
+$constructor='autohash_new (wrap real)';
 for(my $i=0; $i<=3; $i++) {
   for my $test qw(func ashash exthash) {
     undef $autohash; undef $object; untie %hash; undef %hash;
@@ -92,7 +92,7 @@
     no strict 'refs';
     &$sub($constructor,$i,\%VALUES_SV,'hash',undef);
   }}
-my $constructor='autohash_new (wrap tied)';
+$constructor='autohash_new (wrap tied)';
 for(my $i=0; $i<=3; $i++) {
    for my $test qw(func ashash exthash extobj) {
     undef $autohash; undef $object; untie %hash; undef %hash;
@@ -102,7 +102,7 @@
     no strict 'refs';
     &$sub($constructor,$i,\%VALUES_MV,'hash','object');
   }}
-my $constructor='autohash_new (wrap object)';
+$constructor='autohash_new (wrap object)';
 for(my $i=0; $i<=3; $i++) {
    for my $test qw(func ashash exthash extobj) {
     undef $autohash; undef $object; untie %hash; undef %hash;
@@ -112,7 +112,7 @@
     no strict 'refs';
     &$sub($constructor,$i,\%VALUES_MV,'hash','object');
   }}
-my $constructor='autohash_new (wraptie)';
+$constructor='autohash_new (wraptie)';
 for(my $i=0; $i<=3; $i++) {
    for my $test qw(func ashash exthash extobj) {
     undef $autohash; undef $object; untie %hash; undef %hash;
@@ -123,7 +123,7 @@
     &$sub($constructor,$i,\%VALUES_MV,'hash','object');
   }}
 
-my $constructor='autohash_hash';
+$constructor='autohash_hash';
 for(my $i=0; $i<=3; $i++) {
   for my $test qw(func ashash) {
     undef $autohash; undef $object; untie %hash; undef %hash;
@@ -132,7 +132,7 @@
     no strict 'refs';
     &$sub($constructor,$i,\%VALUES_SV);
   }}
-my $constructor='autohash_tie';
+$constructor='autohash_tie';
 for(my $i=0; $i<=3; $i++) {
   for my $test qw(func ashash) {
     undef $autohash; undef $object; untie %hash; undef %hash;
@@ -141,7 +141,7 @@
     no strict 'refs';
     &$sub($constructor,$i,\%VALUES_MV);
   }}
-my $constructor='autohash_wrap (real)';
+$constructor='autohash_wrap (real)';
 for(my $i=0; $i<=3; $i++) {
   for my $test qw(func ashash exthash) {
     undef $autohash; undef $object; untie %hash; undef %hash;
@@ -150,7 +150,7 @@
     no strict 'refs';
     &$sub($constructor,$i,\%VALUES_SV,'hash',undef);
   }}
-my $constructor='autohash_wrap (tied)';
+$constructor='autohash_wrap (tied)';
 for(my $i=0; $i<=3; $i++) {
    for my $test qw(func ashash exthash extobj) {
      undef $autohash; undef $object; untie %hash; undef %hash;
@@ -160,7 +160,7 @@
      no strict 'refs';
      &$sub($constructor,$i,\%VALUES_MV,'hash','object');
   }}
-my $constructor='autohash_wrapobj';
+$constructor='autohash_wrapobj';
 for(my $i=0; $i<=3; $i++) {
    for my $test qw(func ashash exthash extobj) {
      undef $autohash; undef $object; untie %hash; undef %hash;
@@ -170,7 +170,7 @@
      no strict 'refs';
      &$sub($constructor,$i,\%VALUES_MV,'hash','object');
    }}
-my $constructor='autohash_wraptie';
+$constructor='autohash_wraptie';
 for(my $i=0; $i<=3; $i++) {
    for my $test qw(func ashash exthash extobj) {
      undef $autohash; undef $object; untie %hash; undef %hash;
@@ -181,4 +181,4 @@
      &$sub($constructor,$i,\%VALUES_MV,'hash','object');
    }}
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.030.each.t Hash-AutoHash-1.12/t/autohash.030.each.t
--- Hash-AutoHash-1.12-orig/t/autohash.030.each.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.030.each.t	2010-07-28 18:24:21.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 require 'autohash.TieMV.pm';	# example tied hash class
 use autohashUtil;
@@ -28,16 +28,16 @@
   while(my($key,$value)=autohash_each($autohash)) {$actual{$key}=$value;}
   cmp_deeply(\%actual,\%correct,"$label each list context 1st loop via function");
   # do it again to make sure iterator resets correctly
-  my %actual;
+  %actual;
   while(my($key,$value)=autohash_each($autohash)) {$actual{$key}=$value;}
   cmp_deeply(\%actual,\%correct,"$label each list context 2nd loop via function");
   #
   # as hash
-  my %actual;
+  %actual;
   while(my($key,$value)=each %$autohash) {$actual{$key}=$value;}
   cmp_deeply(\%actual,\%correct,"$label each list context 1st loop as hash");
   # do it again to make sure iterator resets correctly
-  my %actual;
+  %actual;
   while(my($key,$value)=each %$autohash) {$actual{$key}=$value;}
   cmp_deeply(\%actual,\%correct,"$label each list context 2nd loop as hash");
   #
@@ -47,7 +47,7 @@
     while(my($key,$value)=each %hash) {$actual{$key}=$value;}
     cmp_deeply(\%actual,\%correct,"$label each list context 1st loop external hash");
     # do it again to make sure iterator resets correctly
-    my %actual;
+    %actual;
     while(my($key,$value)=each %hash) {$actual{$key}=$value;}
     cmp_deeply(\%actual,\%correct,"$label each list context 2nd loop external hash");
   } else {			# should be empty
@@ -60,7 +60,7 @@
     while(my($key,$value)=each_obj($object)) {$actual{$key}=$value;}
     cmp_deeply(\%actual,\%correct,"$label each list context 1st loop external object");
     # do it again to make sure iterator resets correctly
-    my %actual;
+    %actual;
     while(my($key,$value)=each_obj($object)) {$actual{$key}=$value;}
     cmp_deeply(\%actual,\%correct,"$label each list context 2nd loop external object");
   } else {			# should be undef
@@ -120,21 +120,21 @@
   $autohash=autohash_new @initial_values;
   test_each($constructor,$i,$VALUES_SV);
 }
-my $constructor='autohash_new (tie)';
+$constructor='autohash_new (tie)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_new ['TieMV'],@initial_values;
   test_each($constructor,$i,$VALUES_MV);
 }
-my $constructor='autohash_new (wrap real)';
+$constructor='autohash_new (wrap real)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_new \%hash,@initial_values;
   test_each($constructor,$i,$VALUES_SV,'hash',undef);
 }
-my $constructor='autohash_new (wrap tied)';
+$constructor='autohash_new (wrap tied)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -142,7 +142,7 @@
   $autohash=autohash_new \%hash,@initial_values;
   test_each($constructor,$i,$VALUES_MV,'hash','object');
 }
-my $constructor='autohash_new (wrap object)';
+$constructor='autohash_new (wrap object)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -150,7 +150,7 @@
   $autohash=autohash_new $object,@initial_values;
   test_each($constructor,$i,$VALUES_MV,'hash','object');
 }
-my $constructor='autohash_new (wraptie)';
+$constructor='autohash_new (wraptie)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -159,28 +159,28 @@
   test_each($constructor,$i,$VALUES_MV,'hash','object');
 }
 
-my $constructor='autohash_hash';
+$constructor='autohash_hash';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_hash @initial_values;
   test_each($constructor,$i,$VALUES_SV);
 }
-my $constructor='autohash_tie';
+$constructor='autohash_tie';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_tie TieMV,@initial_values;
   test_each($constructor,$i,$VALUES_MV);
 }
-my $constructor='autohash_wrap (real)';
+$constructor='autohash_wrap (real)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_wrap %hash,@initial_values;
   test_each($constructor,$i,$VALUES_SV,'hash',undef);
 }
-my $constructor='autohash_wrap (tied)';
+$constructor='autohash_wrap (tied)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -188,7 +188,7 @@
   $autohash=autohash_wrap %hash,@initial_values;
   test_each($constructor,$i,$VALUES_MV,'hash','object');
 }
-my $constructor='autohash_wrapobj';
+$constructor='autohash_wrapobj';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -196,7 +196,7 @@
   $autohash=autohash_wrapobj $object,@initial_values;
   test_each($constructor,$i,$VALUES_MV,'hash','object');
 }
-my $constructor='autohash_wraptie';
+$constructor='autohash_wraptie';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -205,4 +205,4 @@
   test_each($constructor,$i,$VALUES_MV,'hash','object');
 }
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.030.exists.t Hash-AutoHash-1.12/t/autohash.030.exists.t
--- Hash-AutoHash-1.12-orig/t/autohash.030.exists.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.030.exists.t	2010-07-28 18:11:03.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 require 'autohash.TieMV.pm';	# example tied hash class
 use autohashUtil;
@@ -46,21 +46,21 @@
   $autohash=autohash_new @initial_values;
   test_exists($constructor,$i);
 }
-my $constructor='autohash_new (tie)';
+$constructor='autohash_new (tie)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} ($i..2));
   $autohash=autohash_new ['TieMV'],@initial_values;
   test_exists($constructor,$i);
 }
-my $constructor='autohash_new (wrap real)';
+$constructor='autohash_new (wrap real)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} ($i..2));
   $autohash=autohash_new \%hash,@initial_values;
   test_exists($constructor,$i,'hash',undef);
 }
-my $constructor='autohash_new (wrap tied)';
+$constructor='autohash_new (wrap tied)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} ($i..2));
@@ -68,7 +68,7 @@
   $autohash=autohash_new \%hash,@initial_values;
   test_exists($constructor,$i,'hash','object');
 }
-my $constructor='autohash_new (wrap object)';
+$constructor='autohash_new (wrap object)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} ($i..2));
@@ -76,7 +76,7 @@
   $autohash=autohash_new $object,@initial_values;
   test_exists($constructor,$i,'hash','object');
 }
-my $constructor='autohash_new (wraptie)';
+$constructor='autohash_new (wraptie)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} ($i..2));
@@ -85,28 +85,28 @@
   test_exists($constructor,$i,'hash','object');
 }
 
-my $constructor='autohash_hash';
+$constructor='autohash_hash';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} ($i..2));
   $autohash=autohash_hash @initial_values;
   test_exists($constructor,$i);
 }
-my $constructor='autohash_tie';
+$constructor='autohash_tie';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} ($i..2));
   $autohash=autohash_tie TieMV,@initial_values;
   test_exists($constructor,$i);
 }
-my $constructor='autohash_wrap (real)';
+$constructor='autohash_wrap (real)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} ($i..2));
   $autohash=autohash_wrap %hash,@initial_values;
   test_exists($constructor,$i,'hash',undef);
 }
-my $constructor='autohash_wrap (tied)';
+$constructor='autohash_wrap (tied)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} ($i..2));
@@ -114,7 +114,7 @@
   $autohash=autohash_wrap %hash,@initial_values;
   test_exists($constructor,$i,'hash','object');
 }
-my $constructor='autohash_wrapobj';
+$constructor='autohash_wrapobj';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} ($i..2));
@@ -122,7 +122,7 @@
   $autohash=autohash_wrapobj $object,@initial_values;
   test_exists($constructor,$i,'hash','object');
 }
-my $constructor='autohash_wraptie';
+$constructor='autohash_wraptie';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} ($i..2));
@@ -131,4 +131,4 @@
   test_exists($constructor,$i,'hash','object');
 }
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.030.get.t Hash-AutoHash-1.12/t/autohash.030.get.t
--- Hash-AutoHash-1.12-orig/t/autohash.030.get.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.030.get.t	2010-07-28 18:14:19.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 require 'autohash.TieMV.pm';	# example tied hash class
 use autohashUtil;
@@ -38,45 +38,45 @@
 # get 1 key
 our @keys=qw(key2);
 $autohash=autohash_new (key1=>'value10',key2=>'value20');
-my @correct=('value20');
+@correct=('value20');
 test_get('1 key autohash_new',@correct);
 $autohash=autohash_tie TieMV;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(['value20']);
+@correct=(['value20']);
 test_get('1 key autohash_tie',@correct);
 $autohash=autohash_wrap %hash,(key1=>'value10',key2=>'value20');
-my @correct=('value20');
+@correct=('value20');
 test_get('1 key autohash_wrap',@correct);
 $autohash=autohash_wraptie %tie,TieMV;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(['value20']);
+@correct=(['value20']);
 test_get('1 key autohash_wraptie',@correct);
 $object=tie %tie,'TieMV';
 $autohash=autohash_wrapobj $object;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(['value20']);
+@correct=(['value20']);
 test_get('1 key autohash_wrapobj',@correct);
 
 # get 2 keys
 our @keys=qw(key0 key2);
 $autohash=autohash_new (key1=>'value10',key2=>'value20');
-my @correct=(undef,'value20');
+@correct=(undef,'value20');
 test_get('2 keys autohash_new',@correct);
 $autohash=autohash_tie TieMV;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(undef,['value20']);
+@correct=(undef,['value20']);
 test_get('2 keys autohash_tie',@correct);
 $autohash=autohash_wrap %hash,(key1=>'value10',key2=>'value20');
-my @correct=(undef,'value20');
+@correct=(undef,'value20');
 test_get('2 keys autohash_wrap',@correct);
 $autohash=autohash_wraptie %tie,TieMV;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(undef,['value20']);
+@correct=(undef,['value20']);
 test_get('2 keys autohash_wraptie',@correct);
 $object=tie %tie,'TieMV';
 $autohash=autohash_wrapobj $object;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(undef,['value20']);
+@correct=(undef,['value20']);
 test_get('2 keys autohash_wrapobj',@correct);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.030.keys.t Hash-AutoHash-1.12/t/autohash.030.keys.t
--- Hash-AutoHash-1.12-orig/t/autohash.030.keys.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.030.keys.t	2010-07-28 18:15:11.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 require 'autohash.TieMV.pm';	# example tied hash class
 use autohashUtil;
@@ -17,9 +17,9 @@
   my @correct=@KEYS[0..$how_many-1];
   my @actual=autohash_keys($autohash);
   cmp_set(\@actual,\@correct,"$label keys via function");
-  my @actual=keys %$autohash;
+  @actual=keys %$autohash;
   cmp_set(\@actual,\@correct,"$label keys as hash");
-  my @actual=keys %hash;
+  @actual=keys %hash;
   cmp_set(\@actual,($ok_hash? \@correct: []),"$label keys external hash");
   if ($ok_object) {
     my @actual=keys_obj($object);
@@ -36,21 +36,21 @@
   $autohash=autohash_new @initial_values;
   test_keys($constructor,$i);
 }
-my $constructor='autohash_new (tie)';
+$constructor='autohash_new (tie)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_new ['TieMV'],@initial_values;
   test_keys($constructor,$i);
 }
-my $constructor='autohash_new (wrap real)';
+$constructor='autohash_new (wrap real)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_new \%hash,@initial_values;
   test_keys($constructor,$i,'hash',undef);
 }
-my $constructor='autohash_new (wrap tied)';
+$constructor='autohash_new (wrap tied)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -58,7 +58,7 @@
   $autohash=autohash_new \%hash,@initial_values;
   test_keys($constructor,$i,'hash','object');
 }
-my $constructor='autohash_new (wrap object)';
+$constructor='autohash_new (wrap object)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -66,7 +66,7 @@
   $autohash=autohash_new $object,@initial_values;
   test_keys($constructor,$i,'hash','object');
 }
-my $constructor='autohash_new (wraptie)';
+$constructor='autohash_new (wraptie)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -75,28 +75,28 @@
   test_keys($constructor,$i,'hash','object');
 }
 
-my $constructor='autohash_hash';
+$constructor='autohash_hash';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_hash @initial_values;
   test_keys($constructor,$i);
 }
-my $constructor='autohash_tie';
+$constructor='autohash_tie';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_tie TieMV,@initial_values;
   test_keys($constructor,$i);
 }
-my $constructor='autohash_wrap (real)';
+$constructor='autohash_wrap (real)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_wrap %hash,@initial_values;
   test_keys($constructor,$i,'hash',undef);
 }
-my $constructor='autohash_wrap (tied)';
+$constructor='autohash_wrap (tied)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -104,7 +104,7 @@
   $autohash=autohash_wrap %hash,@initial_values;
   test_keys($constructor,$i,'hash','object');
 }
-my $constructor='autohash_wrapobj';
+$constructor='autohash_wrapobj';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -112,7 +112,7 @@
   $autohash=autohash_wrapobj $object,@initial_values;
   test_keys($constructor,$i,'hash','object');
 }
-my $constructor='autohash_wraptie';
+$constructor='autohash_wraptie';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -121,4 +121,4 @@
   test_keys($constructor,$i,'hash','object');
 }
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.030.set.t Hash-AutoHash-1.12/t/autohash.030.set.t
--- Hash-AutoHash-1.12-orig/t/autohash.030.set.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.030.set.t	2010-07-28 18:18:50.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 use Storable qw(dclone);
 require 'autohash.TieMV.pm';	# example tied hash class
@@ -25,13 +25,13 @@
   }
   report($label,@ok,@fail);
   # test separate ARRAYs form
-  my($label,$hash,@values)=@_;	# restore parameters changed by first test
+  ($label,$hash,@values)=@_;	# restore parameters changed by first test
   $autohash=$autohash_sav;
   $label="set $label: separate ARRAYs form";
   my $keys=[keys %hash];
   my $values=[values %hash];
   autohash_set($autohash,$keys,$values);
-  my(@ok,@fail);
+  (@ok,@fail);
   for my $key (@keys) {
     my $value=shift @values;
     eq_deeply(autohash_get($autohash,$key),$value)? push(@ok,$key): push(@fail,$key);
@@ -48,67 +48,67 @@
 test_set('0 keys autohash_new',@hash,@correct);
 $autohash=autohash_tie TieMV;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(undef,['value10'],['value20'],undef);
+@correct=(undef,['value10'],['value20'],undef);
 test_set('0 keys autohash_tie',@hash,@correct);
 $autohash=autohash_wrap %hash,(key1=>'value10',key2=>'value20');
-my @correct=(undef,'value10','value20',undef);
+@correct=(undef,'value10','value20',undef);
 test_set('0 keys autohash_wrap',@hash,@correct);
 $autohash=autohash_wraptie %tie,TieMV;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(undef,['value10'],['value20'],undef);
+@correct=(undef,['value10'],['value20'],undef);
 test_set('0 keys autohash_wraptie',@hash,@correct);
 $object=tie %tie,'TieMV';
 $autohash=autohash_wrapobj $object;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(undef,['value10'],['value20'],undef);
+@correct=(undef,['value10'],['value20'],undef);
 test_set('0 keys autohash_wrapobj',@hash,@correct);
 
 # set 1 key
 use Hash::AutoHash qw(autohash_get autohash_set);
 our @keys=qw(key0 key1 key2 key3);
-my @hash=(key2=>'value21');
+@hash=(key2=>'value21');
 $autohash=autohash_new (key1=>'value10',key2=>'value20');
-my @correct=(undef,'value10','value21',undef);
+@correct=(undef,'value10','value21',undef);
 test_set('1 key autohash_new',@hash,@correct);
 $autohash=autohash_tie TieMV;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(undef,['value10'],['value20','value21'],undef);
+@correct=(undef,['value10'],['value20','value21'],undef);
 test_set('1 key autohash_tie',@hash,@correct);
 $autohash=autohash_wrap %hash,(key1=>'value10',key2=>'value20');
-my @correct=(undef,'value10','value21',undef);
+@correct=(undef,'value10','value21',undef);
 test_set('1 key autohash_wrap',@hash,@correct);
 $autohash=autohash_wraptie %tie,TieMV;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(undef,['value10'],['value20','value21'],undef);
+@correct=(undef,['value10'],['value20','value21'],undef);
 test_set('1 key autohash_wraptie',@hash,@correct);
 $object=tie %tie,'TieMV';
 $autohash=autohash_wrapobj $object;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(undef,['value10'],['value20','value21'],undef);
+@correct=(undef,['value10'],['value20','value21'],undef);
 test_set('1 key autohash_wrapobj',@hash,@correct);
 
 # set 2 keys
 use Hash::AutoHash qw(autohash_set);
 our @keys=qw(key0 key1 key2 key3);
-my @hash=(key0=>'value01',key2=>'value21');
+@hash=(key0=>'value01',key2=>'value21');
 $autohash=autohash_new (key1=>'value10',key2=>'value20');
-my @correct=('value01','value10','value21',undef);
+@correct=('value01','value10','value21',undef);
 test_set('2 keys autohash_new',@hash,@correct);
 $autohash=autohash_tie TieMV;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(['value01'],['value10'],['value20','value21'],undef);
+@correct=(['value01'],['value10'],['value20','value21'],undef);
 test_set('2 keys autohash_tie',@hash,@correct);
 $autohash=autohash_wrap %hash,(key1=>'value10',key2=>'value20');
-my @correct=('value01','value10','value21',undef);
+@correct=('value01','value10','value21',undef);
 test_set('2 keys autohash_wrap',@hash,@correct);
 $autohash=autohash_wraptie %tie,TieMV;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(['value01'],['value10'],['value20','value21'],undef);
+@correct=(['value01'],['value10'],['value20','value21'],undef);
 test_set('2 keys autohash_wraptie',@hash,@correct);
 $object=tie %tie,'TieMV';
 $autohash=autohash_wrapobj $object;
 $autohash->key1('value10'); $autohash->key2('value20');
-my @correct=(['value01'],['value10'],['value20','value21'],undef);
+@correct=(['value01'],['value10'],['value20','value21'],undef);
 test_set('2 keys autohash_wrapobj',@hash,@correct);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.030.tied.t Hash-AutoHash-1.12/t/autohash.030.tied.t
--- Hash-AutoHash-1.12-orig/t/autohash.030.tied.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.030.tied.t	2010-07-28 18:28:04.000000000 +0200
@@ -4,7 +4,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::Deep;
 use autohashUtil;
 require 'autohash.01x.constructors.pm';
@@ -22,7 +22,7 @@
   my($label)=@_;
   my $tied=tied %$autohash;
   my $correct_autohash=(!$tied || 'Hash::AutoHash::alias' eq ref $tied)? undef: $tied;
-  my $tied=tied %hash;
+  $tied=tied %hash;
 #  my $correct_hash=!$tied? undef: 'Hash::AutoHash::alias' eq ref $tied? tied %{$tied->[0]}: $tied;
   my $correct_hash=!$tied? undef: 'Hash::AutoHash::alias' eq ref $tied? $correct_autohash: $tied;
   my(@ok,@fail);
@@ -113,50 +113,50 @@
 my $label="$constructor without initial values";
 $autohash=autohash_hash;
 cmp_tied($label);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_hash (key1=>'value11',key2=>'value21');
 cmp_tied($label);
 
 # autohash_tie
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_tie';
-my $label="$constructor without initial values";
+$constructor='autohash_tie';
+$label="$constructor without initial values";
 $autohash=autohash_tie TieOptions;
 cmp_tied($label);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_tie TieOptions,(key1=>'value11',key2=>'value21');
 cmp_tied($label);
 
 # autohash_wrap (real)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wrap (real)';
-my $label="$constructor without initial values";
+$constructor='autohash_wrap (real)';
+$label="$constructor without initial values";
 $autohash=autohash_wrap %hash;
 cmp_tied($label);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_wrap %hash,(key1=>'value11',key2=>'value21');
 cmp_tied($label);
 
 # autohash_wrap (tied)
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wrap (tied)';
-my $label="$constructor without initial values";
+$constructor='autohash_wrap (tied)';
+$label="$constructor without initial values";
 $object=tie %hash,'TieOptions';
 $autohash=autohash_wrap %hash;
 cmp_tied($label);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieOptions';
 $autohash=autohash_wrap %hash,(key1=>'value11',key2=>'value21');
 cmp_tied($label);
 
 # autohash_wrapobj
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wrapobj';
-my $label="$constructor without initial values";
+$constructor='autohash_wrapobj';
+$label="$constructor without initial values";
 $object=tie %hash,'TieOptions';
 $autohash=autohash_wrapobj $object;
 cmp_tied($label);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $object=tie %hash,'TieOptions';
 $autohash=autohash_wrapobj $object,(key1=>'value11',key2=>'value21');
 cmp_tied($label);
@@ -164,12 +164,12 @@
 
 # autohash_wraptie
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $constructor='autohash_wraptie';
-my $label="$constructor without initial values";
+$constructor='autohash_wraptie';
+$label="$constructor without initial values";
 $autohash=autohash_wraptie %hash,TieOptions;
 $object=tied(%hash);
 cmp_tied($label);
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_wraptie %hash,TieOptions,(key1=>'value11',key2=>'value21');
 $object=tied(%hash);
 cmp_tied($label);
@@ -178,144 +178,144 @@
 # test on all alias cases (code adapted from 030.alias.t)
 ################################################################################
 # autohash_alias (wrap real)
-my $constructor='autohash_alias (wrap real)';
+$constructor='autohash_alias (wrap real)';
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor without initial values";
+$label="$constructor without initial values";
 autohash_alias $autohash,%hash;
 cmp_tied($label);
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_tied($label);
 
 # autohash_alias (wrap tied)
-my $constructor='autohash_alias (wrap tied)';
+$constructor='autohash_alias (wrap tied)';
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor without initial values";
+$label="$constructor without initial values";
 tie %hash,'TieOptions';
 autohash_alias $autohash,%hash;
 cmp_tied($label);
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 tie %hash,'TieOptions';
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_tied($label);
 
 # autohash_hash
-my $constructor='autohash_alias autohash_hash';
+$constructor='autohash_alias autohash_hash';
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor without initial values";
+$label="$constructor without initial values";
 $autohash=autohash_hash;
 autohash_alias $autohash,%hash;
 cmp_tied($label);
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_hash (key1=>'value11',key2=>'value21');
 autohash_alias $autohash,%hash;
 cmp_tied($label);
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor alias with initial values";
+$label="$constructor alias with initial values";
 $autohash=autohash_hash;
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_tied($label);
 
 # autohash_tie
-my $constructor='autohash_alias autohash_tie';
+$constructor='autohash_alias autohash_tie';
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor without initial values";
+$label="$constructor without initial values";
 $autohash=autohash_tie TieOptions;
 autohash_alias $autohash,%hash;
 cmp_tied($label);
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor with initial values";
+$label="$constructor with initial values";
 $autohash=autohash_tie TieOptions,(key1=>'value11',key2=>'value21');
 autohash_alias $autohash,%hash;
 cmp_tied($label);
 undef $autohash; undef $object; untie %hash; undef %hash;
-my $label="$constructor alias with initial values";
+$label="$constructor alias with initial values";
 $autohash=autohash_tie TieOptions;
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_tied($label);
 
 # autohash_wrap (real)
-my $constructor='autohash_alias autohash_wrap (real)';
+$constructor='autohash_alias autohash_wrap (real)';
 undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor without initial values";
+$label="$constructor without initial values";
 $autohash=autohash_wrap %source;
 autohash_alias $autohash,%hash;
 cmp_tied($label);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor with initial values";
 $autohash=autohash_wrap %source,(key1=>'value11',key2=>'value21');
 autohash_alias $autohash,%hash;
 cmp_tied($label);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor alias with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor alias with initial values";
 $autohash=autohash_wrap %source;
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_tied($label);
 
 # autohash_wrap (tied)
-my $constructor='autohash_alias autohash_wrap (tied)';
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor without initial values";
+$constructor='autohash_alias autohash_wrap (tied)';
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor without initial values";
 $object=tie %source,'TieOptions';
 $autohash=autohash_wrap %source;
 autohash_alias $autohash,%hash;
 cmp_tied($label);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor with initial values";
 $object=tie %source,'TieOptions';
 $autohash=autohash_wrap %source,(key1=>'value11',key2=>'value21');
 autohash_alias $autohash,%hash;
 cmp_tied($label);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor alias with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor alias with initial values";
 $object=tie %source,'TieOptions';
 $autohash=autohash_wrap %source;
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_tied($label);
 
 # autohash_wrapobj
-my $constructor='autohash_alias autohash_wrapobj';
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor without initial values";
+$constructor='autohash_alias autohash_wrapobj';
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor without initial values";
 $object=tie %source,'TieOptions';
 $autohash=autohash_wrapobj $object;
 autohash_alias $autohash,%hash;
 cmp_tied($label);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor with initial values";
 $object=tie %source,'TieOptions';
 $autohash=autohash_wrapobj $object,(key1=>'value11',key2=>'value21');
 autohash_alias $autohash,%hash;
 cmp_tied($label);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor alias with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor alias with initial values";
 $object=tie %source,'TieOptions';
 $autohash=autohash_wrapobj $object;
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_tied($label);
 
 # autohash_wraptie
-my $constructor='autohash_alias autohash_wraptie';
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor without initial values";
+$constructor='autohash_alias autohash_wraptie';
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor without initial values";
 $autohash=autohash_wraptie %source,TieOptions;
 $object=tied(%source);
 autohash_alias $autohash,%hash;
 cmp_tied($label);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor with initial values";
 $autohash=autohash_wraptie %source,TieOptions,(key1=>'value11',key2=>'value21');
 $object=tied(%source);
 autohash_alias $autohash,%hash;
 cmp_tied($label);
-undef $autohash; undef $object; untie %hash; undef %hash; my %source;
-my $label="$constructor alias with initial values";
+undef $autohash; undef $object; untie %hash; undef %hash; %source;
+$label="$constructor alias with initial values";
 $autohash=autohash_wraptie %source,TieOptions;
 $object=tied(%source);
 autohash_alias $autohash,%hash,key1=>'value11',key2=>'value21';
 cmp_tied($label);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.030.values.t Hash-AutoHash-1.12/t/autohash.030.values.t
--- Hash-AutoHash-1.12-orig/t/autohash.030.values.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.030.values.t	2010-07-28 18:30:01.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 require 'autohash.TieMV.pm';	# example tied hash class
 use autohashUtil;
@@ -20,9 +20,9 @@
   my @correct=@$values[0..$how_many-1];
   my @actual=autohash_values($autohash);
   cmp_set(\@actual,\@correct,"$label values via function");
-  my @actual=values %$autohash;
+  @actual=values %$autohash;
   cmp_set(\@actual,\@correct,"$label values as hash");
-  my @actual=values %hash;
+  @actual=values %hash;
   cmp_set(\@actual,($ok_hash? \@correct: []),"$label values external hash");
   if ($ok_object) {
     my @actual=values_obj($object);
@@ -39,21 +39,21 @@
   $autohash=autohash_new @initial_values;
   test_values($constructor,$i,$VALUES_SV);
 }
-my $constructor='autohash_new (tie)';
+$constructor='autohash_new (tie)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_new ['TieMV'],@initial_values;
   test_values($constructor,$i,$VALUES_MV);
 }
-my $constructor='autohash_new (wrap real)';
+$constructor='autohash_new (wrap real)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_new \%hash,@initial_values;
   test_values($constructor,$i,$VALUES_SV,'hash',undef);
 }
-my $constructor='autohash_new (wrap tied)';
+$constructor='autohash_new (wrap tied)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -61,7 +61,7 @@
   $autohash=autohash_new \%hash,@initial_values;
   test_values($constructor,$i,$VALUES_MV,'hash','object');
 }
-my $constructor='autohash_new (wrap object)';
+$constructor='autohash_new (wrap object)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -69,7 +69,7 @@
   $autohash=autohash_new $object,@initial_values;
   test_values($constructor,$i,$VALUES_MV,'hash','object');
 }
-my $constructor='autohash_new (wraptie)';
+$constructor='autohash_new (wraptie)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -78,28 +78,28 @@
   test_values($constructor,$i,$VALUES_MV,'hash','object');
 }
 
-my $constructor='autohash_hash';
+$constructor='autohash_hash';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_hash @initial_values;
   test_values($constructor,$i,$VALUES_SV);
 }
-my $constructor='autohash_tie';
+$constructor='autohash_tie';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_tie TieMV,@initial_values;
   test_values($constructor,$i,$VALUES_MV);
 }
-my $constructor='autohash_wrap (real)';
+$constructor='autohash_wrap (real)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
   $autohash=autohash_wrap %hash,@initial_values;
   test_values($constructor,$i,$VALUES_SV,'hash',undef);
 }
-my $constructor='autohash_wrap (tied)';
+$constructor='autohash_wrap (tied)';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -107,7 +107,7 @@
   $autohash=autohash_wrap %hash,@initial_values;
   test_values($constructor,$i,$VALUES_MV,'hash','object');
 }
-my $constructor='autohash_wrapobj';
+$constructor='autohash_wrapobj';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -115,7 +115,7 @@
   $autohash=autohash_wrapobj $object,@initial_values;
   test_values($constructor,$i,$VALUES_MV,'hash','object');
 }
-my $constructor='autohash_wraptie';
+$constructor='autohash_wraptie';
 for(my $i=0; $i<=3; $i++) {
   undef $autohash; undef $object; untie %hash; undef %hash;
   my @initial_values=(map {'key'.$_=>$INITIAL_VALUES{'key'.$_}} (0..$i-1));
@@ -124,4 +124,4 @@
   test_values($constructor,$i,$VALUES_MV,'hash','object');
 }
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.031.delete_exists.t Hash-AutoHash-1.12/t/autohash.031.delete_exists.t
--- Hash-AutoHash-1.12-orig/t/autohash.031.delete_exists.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.031.delete_exists.t	2010-07-28 15:20:28.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 require 'autohash.TieMV.pm';	# example tied hash class
 use autohashUtil;
@@ -119,4 +119,4 @@
   test_delete_exists($constructor,$i,'hash','object');
 }
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.031.delete_keys.t Hash-AutoHash-1.12/t/autohash.031.delete_keys.t
--- Hash-AutoHash-1.12-orig/t/autohash.031.delete_keys.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.031.delete_keys.t	2010-07-28 15:20:28.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 require 'autohash.TieMV.pm';	# example tied hash class
 use autohashUtil;
@@ -108,4 +108,4 @@
   test_delete_keys($constructor,$i,'hash','object');
 }
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.031.delete_values.t Hash-AutoHash-1.12/t/autohash.031.delete_values.t
--- Hash-AutoHash-1.12-orig/t/autohash.031.delete_values.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.031.delete_values.t	2010-07-28 15:20:28.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 require 'autohash.TieMV.pm';	# example tied hash class
 use autohashUtil;
@@ -110,4 +110,4 @@
   test_delete_values($constructor,$i,$VALUES_MV,'hash','object');
 }
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.040.destroy.t Hash-AutoHash-1.12/t/autohash.040.destroy.t
--- Hash-AutoHash-1.12-orig/t/autohash.040.destroy.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.040.destroy.t	2010-07-28 15:20:28.000000000 +0200
@@ -2,7 +2,7 @@
 use strict;
 use Carp;
 use Scalar::Util qw(refaddr weaken);
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 require 'autohash.TieMV.pm';	# example tied hash class
 use autohashUtil;
@@ -155,4 +155,4 @@
 $autohash=new Child @INITIAL_VALUES;
 test_destroy($constructor);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.050.child.t Hash-AutoHash-1.12/t/autohash.050.child.t
--- Hash-AutoHash-1.12-orig/t/autohash.050.child.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.050.child.t	2010-07-28 15:20:28.000000000 +0200
@@ -2,7 +2,7 @@
 
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::Deep;               # CAUTION: Test::Deep defines 'isa'. breaks 'isa' tests below
 # use Tie::Hash::MultiValue;	# an example tied hash class
 use autohashUtil;
@@ -121,4 +121,4 @@
 #################################################################################
 test_subclass_special_keys(Child);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.050.grandchild.t Hash-AutoHash-1.12/t/autohash.050.grandchild.t
--- Hash-AutoHash-1.12-orig/t/autohash.050.grandchild.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.050.grandchild.t	2010-07-28 15:20:28.000000000 +0200
@@ -2,7 +2,7 @@
 
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::Deep;               # CAUTION: Test::Deep defines 'isa'. breaks 'isa' tests below
 # use Tie::Hash::MultiValue;	# an example tied hash class
 use autohashUtil;
@@ -144,4 +144,4 @@
 #################################################################################
 test_subclass_special_keys(Grandchild);
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.055.typicalchild.t Hash-AutoHash-1.12/t/autohash.055.typicalchild.t
--- Hash-AutoHash-1.12-orig/t/autohash.055.typicalchild.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.055.typicalchild.t	2010-07-28 15:20:28.000000000 +0200
@@ -2,7 +2,7 @@
 
 use strict;
 use Carp;
-use Test::More;
+use Test::More qw(no_plan);
 # use Test::Deep;               # CAUTION: Test::Deep defines 'isa'. breaks 'isa' tests below
 # use Tie::Hash::MultiValue;	# an example tied hash class
 use autohashUtil;
@@ -175,4 +175,4 @@
 my $actual=typicalchild_notempty($child);
 ok(!$actual,'typicalchild_notempty: false');
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohash.099.docs.t Hash-AutoHash-1.12/t/autohash.099.docs.t
--- Hash-AutoHash-1.12-orig/t/autohash.099.docs.t	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohash.099.docs.t	2010-07-28 15:20:28.000000000 +0200
@@ -1,7 +1,7 @@
 use lib qw(t);
 use Carp;
 use Hash::AutoHash;
-use Test::More;
+use Test::More qw(no_plan);
 use Test::Deep;
 use autohashUtil;
 
@@ -429,4 +429,4 @@
 my @SUBCLASS_EXPORT_OK=qw(learn forget);
 cmp_deeply(\@SUBCLASS_EXPORT_OK,[qw(learn forget)],'SUBCLASS_EXPORT_OK');
 
-done_testing();
+#done_testing();
diff -ruN Hash-AutoHash-1.12-orig/t/autohashUtil.pm Hash-AutoHash-1.12/t/autohashUtil.pm
--- Hash-AutoHash-1.12-orig/t/autohashUtil.pm	2010-03-01 23:58:07.000000000 +0100
+++ Hash-AutoHash-1.12/t/autohashUtil.pm	2010-07-28 15:41:17.000000000 +0200
@@ -82,11 +82,11 @@
   my $actual_hash=ref \%hash;
   my $actual_object=ref $object;
   my $actual_tiedhash=ref tied %hash;
-  $actual_autohash eq $correct_autohash? push(@ok,'autohash'): push(@fail,'autohash');
-  $actual_tied eq $correct_tied? push(@ok,'tied'): push(@fail,'tied');
-  $actual_hash eq $correct_hash? push(@ok,'hash'): push(@fail,'hash');
-  $actual_object eq $correct_object? push(@ok,'object'): push(@fail,'object');
-  $actual_tiedhash eq $correct_tiedhash? push(@ok,'tiedhash'): push(@fail,'tiedhash');
+  $actual_autohash eq $correct_autohash ? push(@ok,'autohash'): push(@fail,'autohash');
+  $actual_tied eq $correct_tied ? push(@ok,'tied'): push(@fail,'tied');
+  $actual_hash eq $correct_hash ? push(@ok,'hash'): push(@fail,'hash');
+  $actual_object eq $correct_object ? push(@ok,'object'): push(@fail,'object');
+  $actual_tiedhash eq $correct_tiedhash ? push(@ok,'tiedhash'): push(@fail,'tiedhash');
   $label.=': types';
   pass($label),return unless @fail;
   fail($label);
@@ -385,7 +385,7 @@
 
   my $can=can $class('can');
   is(ref $can,'CODE','can: can');
-  my $can=can $class('not_defined');
+  $can=can $class('not_defined');
   ok(!$can,'can: can\'t');
 
   if ($class ne 'Hash::AutoHash') {
@@ -394,9 +394,9 @@
   }
   my $isa=$class->isa('Hash::AutoHash');
   is($isa,1,'isa: is Hash::AutoHash');
-  my $isa=$class->isa('UNIVERSAL');
+  $isa=$class->isa('UNIVERSAL');
   is($isa,1,'isa: is UNIVERSAL');
-  my $isa=$class->isa('not_defined');
+  $isa=$class->isa('not_defined');
   ok(!$isa,'isa: isn\'t');
 
   # Test DOES in perls > 5.10. 
@@ -406,9 +406,9 @@
   if ($perl_main==5 && $perl_minor>=10) {
     my $does=DOES $class('Hash::AutoHash');
     is($does,1,'DOES: is Hash::AutoHash');
-    my $does=DOES $class('UNIVERSAL');
+    $does=DOES $class('UNIVERSAL');
     is($does,1,'DOES: is UNIVERSAL');
-    my $does=DOES $class('not_defined');
+    $does=DOES $class('not_defined');
     ok(!$does,'DOES: doesn\'t');
   }

Places

File Hash-AutoHash-1.12_Build_n_Test.patch of Package perl-Hash-AutoHash (Revision 819d5002523db998489c6b86e667b8b7)

Places