This is an automated email from the git hooks/post-receive script. ppm-guest pushed a commit to annotated tag v0.40 in repository libmath-prime-util-perl.
commit 3b6009c37b712e48e9ae115fbd27826e19749a5a Author: Dana Jacobsen <d...@acm.org> Date: Thu Apr 3 15:33:33 2014 -0700 Improve test coverage --- MANIFEST | 1 + TODO | 29 ----------------- bench/bench-primearray.pl | 1 + lib/Math/Prime/Util/PP.pm | 4 +++ t/13-primecount.t | 5 ++- t/17-pseudoprime.t | 6 ++-- t/18-functions.t | 74 +++++++++++++++++++++++------------------- t/19-moebius.t | 2 ++ t/23-random-certs.t | 32 ++++++++++++++++++ t/32-iterators.t | 12 +++++-- t/50-factoring.t | 2 ++ t/80-pp.t | 82 ++++++++++++++++++++++++++++++++++++++++++++--- 12 files changed, 178 insertions(+), 72 deletions(-) diff --git a/MANIFEST b/MANIFEST index 31a067d..486cdc3 100644 --- a/MANIFEST +++ b/MANIFEST @@ -104,6 +104,7 @@ t/20-primorial.t t/21-conseq-lcm.t t/22-aks-prime.t t/23-primality-proofs.t +t/23-random-certs.t t/24-partitions.t t/30-relations.t t/31-threading.t diff --git a/TODO b/TODO index 55c161e..021d8b0 100644 --- a/TODO +++ b/TODO @@ -68,32 +68,3 @@ - Ensure a fast path for Math::GMP from MPU -> MPU:GMP -> GMP, and back. - znlog better implementation - -- coverage: - util.c: modinverse, divmod (from dlp_prho), Ei with x > 2000 - lmo.c: legendre phi - factor.c: factor with a perfect power: e.g. 2*3^2 and 5*7 * 5*7, dlp_prho - Util: random_maurer_prime_with_cert - random_shawe_taylor_prime_with_cert - random_proven_prime_with_cert - miller_rabin_random non-GMP - primorial non-GMP - pn_primorial non-GMP - partitions non-GMP - generic forprimes - generic forcomposites - generic fordivisors - prime_iterator to GMP - prime_iterator to PP - next_prime to PP - prev_prime to PP - prime_count to PP - factor to PP - PP: prime_precalc, prime_memfree - _tiny_prime_count - is_bpsw_prime - partitions, primorial, nth_prime_approx, gcd, lcm,cheb_theta/psi - divisor_sum with overflowing k=2 - trial_factor with bigint - pminus1_factor with stage 2 - ecm_factor with stage 2 diff --git a/bench/bench-primearray.pl b/bench/bench-primearray.pl index 88f0ff6..ff5bd62 100755 --- a/bench/bench-primearray.pl +++ b/bench/bench-primearray.pl @@ -29,6 +29,7 @@ cmpthese($count,{ $s += $_ for @primes[0..$ilimit]; die unless $s == $expect; }, 'pa each' => sub { $s=0; tie my @primes, "Math::Prime::Util::PrimeArray"; + # Note: using last inside each is Very Bad Stuff. while(my(undef,$v) = each @primes) { last if $v > $nlimit; $s += $v; } die $s unless $s == $expect; }, 'pa shift' => sub { $s=0; tie my @primes, "Math::Prime::Util::PrimeArray"; diff --git a/lib/Math/Prime/Util/PP.pm b/lib/Math/Prime/Util/PP.pm index a2c843b..f25fa77 100644 --- a/lib/Math/Prime/Util/PP.pm +++ b/lib/Math/Prime/Util/PP.pm @@ -1336,6 +1336,9 @@ sub prime_count_upper { sub twin_prime_count { my($low,$high) = @_; + if (defined $high) { _validate_positive_integer($low); } + else { ($low,$high) = (2, $low); } + _validate_positive_integer($high); my $sum = 0; # TODO: I suspect calling primes() on segments would be faster in most cases. if ($high >= $low) { @@ -1351,6 +1354,7 @@ sub twin_prime_count { sub twin_prime_count_approx { my($n) = @_; + $n = _upgrade_to_float($n) if ref($n); my $logn = log($n); my $li2 = ExponentialIntegral($logn) + 2.8853900817779268147198494 - ($n/$logn); return int(1.32032363169373914785562422 * $li2 + 0.5); diff --git a/t/13-primecount.t b/t/13-primecount.t index 2d87671..545e8b6 100644 --- a/t/13-primecount.t +++ b/t/13-primecount.t @@ -89,7 +89,7 @@ plan tests => 0 + 1 + scalar(keys %intervals) + 1 + 5 + 2*$extra # prime count specific methods - + 3; # twin prime counts + + 3 + (($isxs && $use64) ? 1 : 0); # twin prime counts ok( eval { prime_count(13); 1; }, "prime_count in void context"); @@ -180,3 +180,6 @@ if ($extra) { is(twin_prime_count(13,31), 2, "twin prime count 13 to 31"); is(twin_prime_count(10**8,10**8+34587), 137, "twin prime count 10^8 to +34587"); is(twin_prime_count(654321), 5744, "twin prime count 654321"); +if ($isxs && $use64) { + is(twin_prime_count(1000000000123456), 1177209242446, "twin prime count 1000000000123456"); +} diff --git a/t/17-pseudoprime.t b/t/17-pseudoprime.t index 978e5f6..2c015ce 100644 --- a/t/17-pseudoprime.t +++ b/t/17-pseudoprime.t @@ -79,9 +79,9 @@ if ($use64) { push @{$pseudoprimes{psp3}}, 4398117272641; push @{$pseudoprimes{3}}, 1099558795087; push @{$pseudoprimes{lucas}}, 2199055761527; - push @{$pseudoprimes{slucas}}, 12598021314449; - push @{$pseudoprimes{eslucas}}, 10099386070337; - push @{$pseudoprimes{aeslucas1}}, 10071551814917; + push @{$pseudoprimes{slucas}}, 4294967311,4294967357,12598021314449; + push @{$pseudoprimes{eslucas}}, 4294967311,4294967357,10099386070337; + push @{$pseudoprimes{aeslucas1}}, 4294967311,4294967357,10071551814917; push @{$pseudoprimes{aeslucas2}}, 34372519409; } diff --git a/t/18-functions.t b/t/18-functions.t index e4dd417..e9d66a6 100644 --- a/t/18-functions.t +++ b/t/18-functions.t @@ -9,26 +9,6 @@ use Math::Prime::Util qw/ my $infinity = 20**20**20; -plan tests => 3 + 6 + 1 + 16 + 11 + 9 + 6; - -eval { LogarithmicIntegral(-1); }; -like($@, qr/invalid/i, "li(-1) is invalid"); -eval { RiemannR(0); }; -like($@, qr/invalid/i, "R(0) is invalid"); -eval { RiemannR(-1); }; -like($@, qr/invalid/i, "R(-1) is invalid"); - -cmp_ok( ExponentialIntegral(0), '<=',-$infinity, "Ei(0) is -infinity"); -cmp_ok( ExponentialIntegral(-$infinity),'==', 0, "Ei(-inf) is 0" ); -cmp_ok( ExponentialIntegral($infinity), '>=', $infinity, "Ei(inf) is infinity"); - -cmp_ok( LogarithmicIntegral(0), '==', 0, "li(0) is 0"); -cmp_ok( LogarithmicIntegral(1), '<=',-$infinity, "li(1) is -infinity"); -cmp_ok( LogarithmicIntegral($infinity), '>=', $infinity, "li(inf) is infinity"); - -# Example used in Math::Cephes -cmp_closeto( ExponentialIntegral(2.2), 5.732614700, 1e-06, "Ei(2.2)"); - my %eivals = ( -10 => -0.00000415696892968532438, -0.5 => -0.55977359477616, @@ -46,14 +26,10 @@ my %eivals = ( 20 => 25615652.664056588820481, 40 => 6039718263611241.5783592, 41 => 16006649143245041.110700, + 79 => 2.61362206325045575e+32, ); -while (my($n, $ein) = each (%eivals)) { - cmp_closeto( ExponentialIntegral($n), $ein, 0.00000001 * abs($ein), "Ei($n) ~= $ein"); -} - -# In pari these are: -eint1(-log($n)) -my %livals = ( +my %livals = ( # In pari these are: -eint1(-log($n)) 0 => 0, 1.01 => -4.0229586739299358695031, 2 => 1.0451637801174927848446, @@ -67,10 +43,6 @@ my %livals = ( 100000000000 => 4118066400.6216115150394, ); -while (my($n, $lin) = each (%livals)) { - cmp_closeto( LogarithmicIntegral($n), $lin, 0.00000001 * abs($lin), "li($n) ~= $lin"); -} - # Values from T. R. Nicely for comparison my %rvals = ( 1.01 => 1.0060697180622924796117, @@ -83,9 +55,6 @@ my %rvals = ( 10000000000 => 455050683.30684692446315, 18446744073709551615 => 4.25656284014012122706963685602e17, ); -while (my($n, $rin) = each (%rvals)) { - cmp_closeto( RiemannR($n), $rin, 0.00000001 * abs($rin), "R($n) ~= $rin"); -} my %rzvals = ( 2 => 0.6449340668482264364724151666, @@ -95,6 +64,45 @@ my %rzvals = ( 8.5 => 0.0028592508824156277133439825, 20.6 => 0.0000006293391573578212882457, ); + + +plan tests => 3 + 6 + 1 + + scalar(keys(%eivals)) + + scalar(keys(%livals)) + + scalar(keys(%rvals)) + + scalar(keys(%rzvals)) + ; + +eval { LogarithmicIntegral(-1); }; +like($@, qr/invalid/i, "li(-1) is invalid"); +eval { RiemannR(0); }; +like($@, qr/invalid/i, "R(0) is invalid"); +eval { RiemannR(-1); }; +like($@, qr/invalid/i, "R(-1) is invalid"); + +cmp_ok( ExponentialIntegral(0), '<=',-$infinity, "Ei(0) is -infinity"); +cmp_ok( ExponentialIntegral(-$infinity),'==', 0, "Ei(-inf) is 0" ); +cmp_ok( ExponentialIntegral($infinity), '>=', $infinity, "Ei(inf) is infinity"); + +cmp_ok( LogarithmicIntegral(0), '==', 0, "li(0) is 0"); +cmp_ok( LogarithmicIntegral(1), '<=',-$infinity, "li(1) is -infinity"); +cmp_ok( LogarithmicIntegral($infinity), '>=', $infinity, "li(inf) is infinity"); + +# Example used in Math::Cephes +cmp_closeto( ExponentialIntegral(2.2), 5.732614700, 1e-06, "Ei(2.2)"); + +while (my($n, $ein) = each (%eivals)) { + cmp_closeto( ExponentialIntegral($n), $ein, 0.00000001 * abs($ein), "Ei($n) ~= $ein"); +} + +while (my($n, $lin) = each (%livals)) { + cmp_closeto( LogarithmicIntegral($n), $lin, 0.00000001 * abs($lin), "li($n) ~= $lin"); +} + +while (my($n, $rin) = each (%rvals)) { + cmp_closeto( RiemannR($n), $rin, 0.00000001 * abs($rin), "R($n) ~= $rin"); +} + while (my($n, $zin) = each (%rzvals)) { cmp_closeto( RiemannZeta($n), $zin, 0.00000001 * abs($zin), "Zeta($n) ~= $zin"); } diff --git a/t/19-moebius.t b/t/19-moebius.t index dc086e4..11415b1 100644 --- a/t/19-moebius.t +++ b/t/19-moebius.t @@ -276,6 +276,7 @@ my @legendre_sums = ( [100000, 7, 18053], [10000, 8, 1711], [1000000, 168, 78331], + [800000, 213, 63739], ); my @gcds = ( @@ -337,6 +338,7 @@ my @znlogs = ( ); if ($usexs) { push @znlogs, [ [5678,5,10007], 8620]; # 5678 = 5^8620 mod 10007 + push @znlogs, [ [5675,5,10000019], 2003974]; # 5675 = 5^2003974 mod 10000019 } my %powers = ( diff --git a/t/23-random-certs.t b/t/23-random-certs.t new file mode 100644 index 0000000..d54773f --- /dev/null +++ b/t/23-random-certs.t @@ -0,0 +1,32 @@ +#!/usr/bin/env perl +use strict; +use warnings; + +use Test::More; +use Math::Prime::Util qw/is_prime verify_prime + random_maurer_prime_with_cert + random_shawe_taylor_prime_with_cert + random_proven_prime_with_cert + /; + +use Math::BigInt try=>"GMP,Pari"; + +plan tests => 3*2; + +{ + my($n,$cert) = random_maurer_prime_with_cert(80); + ok( is_prime($n), "Random Maurer prime returns a prime" ); + ok( verify_prime($cert), " with a valid certificate" ); +} + +{ + my($n,$cert) = random_shawe_taylor_prime_with_cert(80); + ok( is_prime($n), "Random Shawe-Taylor prime returns a prime" ); + ok( verify_prime($cert), " with a valid certificate" ); +} + +{ + my($n,$cert) = random_proven_prime_with_cert(80); + ok( is_prime($n), "Random proven prime returns a prime" ); + ok( verify_prime($cert), " with a valid certificate" ); +} diff --git a/t/32-iterators.t b/t/32-iterators.t index c810bb7..da01f97 100644 --- a/t/32-iterators.t +++ b/t/32-iterators.t @@ -13,13 +13,13 @@ my $use64 = Math::Prime::Util::prime_get_config->{'maxbits'} > 32; my $broken64 = (18446744073709550592 == ~0); plan tests => 8 # forprimes errors - + 12 + 6 # forprimes simple + + 12 + 7 # forprimes simple + 3 # forcomposites simple + 2 # fordivisors simple + 3 # iterator errors + 7 # iterator simple + 2 # forprimes/iterator nesting - + 2 # forprimes BigInt/BigFloat + + 3 # forprimes BigInt/BigFloat + 3 # oo iterator errors + 7 # oo iterator simple + 25 # oo iterator methods @@ -67,6 +67,9 @@ ok(!eval { forprimes { 1 } 5.6; }, "forprimes abc"); { my @t; forprimes { push @t, $_ } 2147483647,2147483659; is_deeply( [@t], [2147483647,2147483659], "forprimes 2147483647,2147483659" ); } +{ my @t; forprimes { push @t, $_ } 3842610774,3842611326; + is_deeply( [@t], [3842611109,3842611139,3842611163,3842611181,3842611211,3842611229,3842611249,3842611259,3842611261,3842611291,3842611301], "forprimes 3842610774,3842611326" ); +} { my @t; forcomposites { push @t, $_ } 2147483647,2147483659; is_deeply( [@t], [qw/2147483648 2147483649 2147483650 2147483651 2147483652 2147483653 2147483654 2147483655 2147483656 2147483657 2147483658/], "forcomposites 2147483647,2147483659" ); } @@ -151,6 +154,11 @@ ok(!eval { prime_iterator(4.5); }, "iterator 4.5"); forprimes { push @t, $_ } Math::BigFloat->new("5"), Math::BigFloat->new("11"); is_deeply( [@t], [5,7,11], "forprimes with BigFloat range" ); } +{my $it = prime_iterator(Math::BigInt->new("68719476736")); + is_deeply( [map { $it->() } 1..3], + [68719476767,68719476851,68719476853], + "iterator 3 primes with BigInt start" ); +} # Test new object iterator ok(!eval { prime_iterator_object(-2); }, "iterator -2"); diff --git a/t/50-factoring.t b/t/50-factoring.t index 49cfbce..ce0d5ed 100644 --- a/t/50-factoring.t +++ b/t/50-factoring.t @@ -33,6 +33,7 @@ my @testn = qw/0 1 2 3 4 5 6 7 8 16 57 64 377 9592 30107 78498 664579 5761455 2231139 2463289 3008891 5115953 6961021 8030207 10486123 10893343 12327779 701737021 549900 10000142 + 392498 /; my @testn64 = qw/37607912018 346065536839 600851475143 @@ -43,6 +44,7 @@ my @testn64 = qw/37607912018 346065536839 600851475143 6469693230 200560490130 7420738134810 304250263527210 13082761331670030 614889782588491410 440091295252541 5333042142001571 + 79127989298 /; push @testn, @testn64 if $use64; diff --git a/t/80-pp.t b/t/80-pp.t index b6033ec..8b6a315 100644 --- a/t/80-pp.t +++ b/t/80-pp.t @@ -250,6 +250,7 @@ plan tests => 2 + 3 + scalar(keys %small_single) + scalar(keys %small_range) + 2*scalar(keys %primegaps) + 8 + 1 + 1 + 1 + scalar(keys %pivals_small) + scalar(keys %pi_intervals) + + 6 + # PC, pc approx 2*scalar(keys %pivals_small) + scalar(keys %nthprimes_small) + 4 + scalar(keys %pseudoprimes) + scalar(keys %eivals) + scalar(keys %livals) + scalar(keys %rvals) + scalar(keys %rzvals) + @@ -258,17 +259,20 @@ plan tests => 2 + 10 + 7*3 + # factoring subs 1 + # HOLF ($extra ? 3 : 0) + # HOLF extra + 3 + # factor stage 2 10 + # AKS ($use64 ? 3 : 2) + # Lucas and BLS75 primality proofs 4 + # M-R and Lucas on bigint - 13 + # Misc util.pm functions + 2 + # PC and NP approx + 26 + # Misc util.pm functions scalar(keys %ipp) + # is_prob_prime 1; -use Math::Prime::Util qw/primes prime_count_approx prime_count_lower +use Math::Prime::Util qw/primes + prime_count_approx nth_prime_approx prime_get_config prime_set_config consecutive_integer_lcm - chebyshev_theta chebyshev_psi + primorial pn_primorial partitions miller_rabin_random is_prob_prime /; use Math::BigInt; @@ -281,7 +285,17 @@ require_ok 'Math::Prime::Util::PrimalityProving'; *primes = \&Math::Prime::Util::PP::primes; *prime_count = \&Math::Prime::Util::PP::prime_count; + *prime_count_lower = \&Math::Prime::Util::PP::prime_count_lower; + *prime_count_upper = \&Math::Prime::Util::PP::prime_count_upper; *nth_prime = \&Math::Prime::Util::PP::nth_prime; + undef *prime_count_approx; + undef *nth_prime_approx; + *prime_count_approx = \&Math::Prime::Util::PP::prime_count_approx; + *nth_prime_approx = \&Math::Prime::Util::PP::nth_prime_approx; + + *twin_prime_count = \&Math::Prime::Util::PP::twin_prime_count; + *nth_twin_prime = \&Math::Prime::Util::PP::nth_twin_prime; + *twin_prime_count_approx = \&Math::Prime::Util::PP::twin_prime_count_approx; *is_prime = \&Math::Prime::Util::PP::is_prime; *next_prime = \&Math::Prime::Util::PP::next_prime; @@ -298,10 +312,15 @@ require_ok 'Math::Prime::Util::PrimalityProving'; *factor = \&Math::Prime::Util::PP::factor; + *gcd = \&Math::Prime::Util::PP::gcd; + *lcm = \&Math::Prime::Util::PP::lcm; + *moebius = \&Math::Prime::Util::PP::moebius; *euler_phi = \&Math::Prime::Util::PP::euler_phi; *mertens = \&Math::Prime::Util::PP::mertens; *exp_mangoldt = \&Math::Prime::Util::PP::exp_mangoldt; + *chebyshev_theta= \&Math::Prime::Util::PP::chebyshev_theta; + *chebyshev_psi = \&Math::Prime::Util::PP::chebyshev_psi; *RiemannR = \&Math::Prime::Util::PP::RiemannR; *RiemannZeta = \&Math::Prime::Util::PP::RiemannZeta; @@ -394,6 +413,15 @@ while (my($range, $expect) = each (%pi_intervals)) { is( prime_count($low,$high), $expect, "prime_count($range) = $expect"); } +# These are small enough they should be exact. +is( prime_count_lower(450), 87, "prime_count_lower(450)" ); +is( prime_count_upper(450), 87, "prime_count_upper(450)" ); +# Make sure these are about right +cmp_closeto( prime_count_lower(1234567), 95327, 10, "prime_count_lower(1234567) in range" ); +cmp_closeto( prime_count_upper(1234567), 95413, 10, "prime_count_upper(1234567) in range" ); +cmp_closeto( prime_count_lower(412345678), 21956686, 1000, "prime_count_lower(412345678) in range" ); +cmp_closeto( prime_count_upper(412345678), 21959328, 1000, "prime_count_upper(412345678) in range" ); + ############################################################################### while (my($n, $pin) = each (%pivals_small)) { @@ -591,6 +619,18 @@ if ($extra) { } } +##### Some numbers that go to stage 2 of tests +{ + my $nbig = Math::BigInt->new("9087500560545072247139"); + my @nfac; + @nfac = sort {$a<=>$b} Math::Prime::Util::PP::pminus1_factor($nbig,1000,10000); + is_deeply( [@nfac], ["24133","376559091722747783"], "p-1 stage 2 finds factors of $nbig" ); + @nfac = sort {$a<=>$b} Math::Prime::Util::PP::trial_factor($nbig, 50000); + is_deeply( [@nfac], ["24133","376559091722747783"], "trial factor finds factors of $nbig" ); + @nfac = sort {$a<=>$b} Math::Prime::Util::PP::ecm_factor($nbig, 10,1000,100); + is_deeply( [@nfac], ["24133","376559091722747783"], "ecm factor finds factors of $nbig" ); +} + ##### AKS primality test. Be very careful with performance. is( is_aks_prime(1), 0, "AKS: 1 is composite (less than 2)" ); is( is_aks_prime(2), 1, "AKS: 2 is prime" ); @@ -603,7 +643,7 @@ is( is_aks_prime(70747), 0, "AKS: 70747 is composite (n mod r)" ); SKIP: { skip "Skipping PP AKS test without EXTENDED_TESTING", 2 unless $extra; diag "32-bit Perl will be very slow for AKS" unless $use64; - is( is_aks_prime(101), 1, "AKS: 101 is prime (passed anr test)" ); + is( is_aks_prime(1009), 1, "AKS: 1009 is prime (passed anr test)" ); is( is_aks_prime(74513), 0, "AKS: 74513 is composite (failed anr test)" ); } @@ -635,6 +675,13 @@ if ($use64) { } { + my $ntha = nth_prime_approx(1287248); + ok( $ntha >= 20274907 && $ntha <= 20284058, "nth_prime_approx(1287248) in range" ); + my $pca = prime_count_approx(128722248); + ok( $pca >= 7309252 && $pca <= 7310044, "prime_count_approx(128722248) in range" ); +} + +{ # Test some functions usually not tested in Util.pm my $xs = prime_get_config->{'xs'}; my $gmp = prime_get_config->{'gmp'}; @@ -668,6 +715,33 @@ if ($use64) { is( is_prob_prime($n), $isp, "is_prob_prime($n) should be $isp" ); } + is( primorial(24), 223092870, "primorial(24)" ); + is( primorial(118), "31610054640417607788145206291543662493274686990", "primorial(118)" ); + is( pn_primorial(7), 510510, "pn_primorial(7)" ); + is( partitions(74), 7089500, "partitions(74)" ); + is( miller_rabin_random(4294967281, 20), "0", "Miller-Rabin random 40 on composite" ); + + { my @t; + Math::Prime::Util::_generic_forprimes(sub {push @t,$_}, 2387234,2387303); + is_deeply( [@t], [2387237,2387243,2387249,2387269,2387291,2387299,2387303], + "generic forprimes 2387234,2387303" ); + } + { my @t; + Math::Prime::Util::_generic_forcomposites(sub {push @t,$_}, 15202630,15202641); + is_deeply( [@t], [15202630,15202632,15202634,15202635,15202636,15202638,15202640,15202641], "generic forcomposites 15202630,15202641" ); + } + { my $k = 0; + Math::Prime::Util::_generic_fordivisors(sub {$k += $_+int(sqrt($_))},92834); + is( $k, 168921, "generic fordivisors: d|92834: k+=d+int(sqrt(d))" ); + } + + is( gcd(-30,-90,90), 30, "gcd(-30,-90,90) = 30" ); + is( lcm(11926,78001,2211), 2790719778, "lcm(11926,78001,2211) = 2790719778" ); + + is( twin_prime_count(4321), 114, "twin_prime_count(4321)" ); + cmp_closeto( twin_prime_count_approx(Math::BigInt->new("412345678412345678412345678")), "149939117920176008847283", 1e10, "twin_prime_count_approx(412345678412345678412345678)" ); + is( nth_twin_prime(977), 76871, "nth_twin_prime(977)" ); + prime_set_config(xs=>$xs, gmp=>$gmp, verbose=>$verbose); } -- Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-perl/packages/libmath-prime-util-perl.git _______________________________________________ Pkg-perl-cvs-commits mailing list Pkg-perl-cvs-commits@lists.alioth.debian.org http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-perl-cvs-commits