Convert bignum tests from Test to Test::More.
authorNicholas Clark <nick@ccl4.org>
Fri, 10 Sep 2010 09:59:00 +0000 (10:59 +0100)
committerNicholas Clark <nick@ccl4.org>
Fri, 10 Sep 2010 09:59:00 +0000 (10:59 +0100)
dist/bignum/t/bigint.t
dist/bignum/t/bignum.t
dist/bignum/t/bigrat.t
dist/bignum/t/biinfnan.t
dist/bignum/t/bn_lite.t
dist/bignum/t/bninfnan.t
dist/bignum/t/br_lite.t
dist/bignum/t/brinfnan.t
dist/bignum/t/infnan.inc

index bef5aec..e9de090 100644 (file)
@@ -2,13 +2,7 @@
 
 ###############################################################################
 
-use Test;
-use strict;
-
-BEGIN
-  {
-  plan tests => 51;
-  }
+use Test::More tests => 51;
 
 use bigint qw/hex oct/;
 
@@ -37,7 +31,7 @@ foreach (qw/
   {
   my ($x,$y) = split /:/;
   print "# Try $x\n";
-  ok (bigint::_float_constant("$x"),"$y");
+  is (bigint::_float_constant("$x"),"$y");
   }
 
 foreach (qw/ 
@@ -49,72 +43,60 @@ foreach (qw/
   {
   my ($x,$y) = split /:/;
   print "# Try $x\n";
-  ok (bigint::_binary_constant("$x"),"$y");
+  is (bigint::_binary_constant("$x"),"$y");
   }
 
 ###############################################################################
 # general tests
 
-my $x = 5; ok (ref($x) =~ /^Math::BigInt/);            # :constant
+my $x = 5; like (ref($x), qr/^Math::BigInt/);          # :constant
 
-# todo:  ok (2 + 2.5,4.5);                             # should still work
-# todo: $x = 2 + 3.5; ok (ref($x),'Math::BigFloat');
+# todo:  is (2 + 2.5,4.5);                             # should still work
+# todo: $x = 2 + 3.5; is (ref($x),'Math::BigFloat');
 
-$x = 2 ** 255; ok (ref($x) =~ /^Math::BigInt/);
+$x = 2 ** 255; like (ref($x), qr/^Math::BigInt/);
 
-ok (12->bfac(),479001600);
-ok (9/4,2);
+is (12->bfac(),479001600);
+is (9/4,2);
 
-ok (4.5+4.5,8);                                        # truncate
-ok (ref(4.5+4.5) =~ /^Math::BigInt/);
+is (4.5+4.5,8);                                        # truncate
+like (ref(4.5+4.5), qr/^Math::BigInt/);
 
 
 ###############################################################################
 # accurarcy and precision
 
-ok_undef (bigint->accuracy());
-ok (bigint->accuracy(12),12);
-ok (bigint->accuracy(),12);
+is (bigint->accuracy(), undef);
+is (bigint->accuracy(12),12);
+is (bigint->accuracy(),12);
 
-ok_undef (bigint->precision());
-ok (bigint->precision(12),12);
-ok (bigint->precision(),12);
+is (bigint->precision(), undef);
+is (bigint->precision(12),12);
+is (bigint->precision(),12);
 
-ok (bigint->round_mode(),'even');
-ok (bigint->round_mode('odd'),'odd');
-ok (bigint->round_mode(),'odd');
+is (bigint->round_mode(),'even');
+is (bigint->round_mode('odd'),'odd');
+is (bigint->round_mode(),'odd');
 
 ###############################################################################
 # hex() and oct()
 
 my $c = 'Math::BigInt';
 
-ok (ref(hex(1)), $c);
-ok (ref(hex(0x1)), $c);
-ok (ref(hex("af")), $c);
-ok (hex("af"), Math::BigInt->new(0xaf));
-ok (ref(hex("0x1")), $c);
-
-ok (ref(oct("0x1")), $c);
-ok (ref(oct("01")), $c);
-ok (ref(oct("0b01")), $c);
-ok (ref(oct("1")), $c);
-ok (ref(oct(" 1")), $c);
-ok (ref(oct(" 0x1")), $c);
-
-ok (ref(oct(0x1)), $c);
-ok (ref(oct(01)), $c);
-ok (ref(oct(0b01)), $c);
-ok (ref(oct(1)), $c);
-
-###############################################################################
-###############################################################################
-# Perl 5.005 does not like ok ($x,undef)
-
-sub ok_undef
-  {
-  my $x = shift;
-
-  ok (1,1) and return if !defined $x;
-  ok ($x,'undef');
-  }
+is (ref(hex(1)), $c);
+is (ref(hex(0x1)), $c);
+is (ref(hex("af")), $c);
+is (hex("af"), Math::BigInt->new(0xaf));
+is (ref(hex("0x1")), $c);
+
+is (ref(oct("0x1")), $c);
+is (ref(oct("01")), $c);
+is (ref(oct("0b01")), $c);
+is (ref(oct("1")), $c);
+is (ref(oct(" 1")), $c);
+is (ref(oct(" 0x1")), $c);
+
+is (ref(oct(0x1)), $c);
+is (ref(oct(01)), $c);
+is (ref(oct(0b01)), $c);
+is (ref(oct(1)), $c);
index d900cbb..6cef537 100644 (file)
@@ -2,90 +2,73 @@
 
 ###############################################################################
 
-use Test;
 use strict;
-
-BEGIN
-  {
-  plan tests => 35;
-  }
+use Test::More tests => 35;
 
 use bignum qw/oct hex/;
 
 ###############################################################################
 # general tests
 
-my $x = 5; ok (ref($x) =~ /^Math::BigInt/);            # :constant
+my $x = 5; like (ref($x), qr/^Math::BigInt/);          # :constant
 
-ok (2 + 2.5,4.5);
-$x = 2 + 3.5; ok (ref($x),'Math::BigFloat');
-ok (2 * 2.1,4.2);
-$x = 2 + 2.1; ok (ref($x),'Math::BigFloat');
+is (2 + 2.5,4.5);
+$x = 2 + 3.5; is (ref($x),'Math::BigFloat');
+is (2 * 2.1,4.2);
+$x = 2 + 2.1; is (ref($x),'Math::BigFloat');
 
-$x = 2 ** 255; ok (ref($x) =~ /^Math::BigInt/);
+$x = 2 ** 255; like (ref($x), qr/^Math::BigInt/);
 
 # see if Math::BigInt constant and upgrading works
-ok (Math::BigInt::bsqrt('12'),'3.464101615137754587054892683011744733886');
-ok (sqrt(12),'3.464101615137754587054892683011744733886');
+is (Math::BigInt::bsqrt('12'),'3.464101615137754587054892683011744733886');
+is (sqrt(12),'3.464101615137754587054892683011744733886');
 
-ok (2/3,"0.6666666666666666666666666666666666666667");
+is (2/3,"0.6666666666666666666666666666666666666667");
 
-#ok (2 ** 0.5, 'NaN'); # should be sqrt(2);
+#is (2 ** 0.5, 'NaN'); # should be sqrt(2);
 
-ok (12->bfac(),479001600);
+is (12->bfac(),479001600);
 
 # see if Math::BigFloat constant works
 
 #                     0123456789          0123456789   <- default 40
 #           0123456789          0123456789
-ok (1/3, '0.3333333333333333333333333333333333333333');
+is (1/3, '0.3333333333333333333333333333333333333333');
 
 ###############################################################################
 # accurarcy and precision
 
-ok_undef (bignum->accuracy());
-ok (bignum->accuracy(12),12);
-ok (bignum->accuracy(),12);
+is (bignum->accuracy(), undef);
+is (bignum->accuracy(12),12);
+is (bignum->accuracy(),12);
 
-ok_undef (bignum->precision());
-ok (bignum->precision(12),12);
-ok (bignum->precision(),12);
+is (bignum->precision(), undef);
+is (bignum->precision(12),12);
+is (bignum->precision(),12);
 
-ok (bignum->round_mode(),'even');
-ok (bignum->round_mode('odd'),'odd');
-ok (bignum->round_mode(),'odd');
+is (bignum->round_mode(),'even');
+is (bignum->round_mode('odd'),'odd');
+is (bignum->round_mode(),'odd');
 
 ###############################################################################
 # hex() and oct()
 
 my $c = 'Math::BigInt';
 
-ok (ref(hex(1)), $c);
-ok (ref(hex(0x1)), $c);
-ok (ref(hex("af")), $c);
-ok (hex("af"), Math::BigInt->new(0xaf));
-ok (ref(hex("0x1")), $c);
-
-ok (ref(oct("0x1")), $c);
-ok (ref(oct("01")), $c);
-ok (ref(oct("0b01")), $c);
-ok (ref(oct("1")), $c);
-ok (ref(oct(" 1")), $c);
-ok (ref(oct(" 0x1")), $c);
-
-ok (ref(oct(0x1)), $c);
-ok (ref(oct(01)), $c);
-ok (ref(oct(0b01)), $c);
-ok (ref(oct(1)), $c);
-
-###############################################################################
-###############################################################################
-# Perl 5.005 does not like ok ($x,undef)
-
-sub ok_undef
-  {
-  my $x = shift;
-
-  ok (1,1) and return if !defined $x;
-  ok ($x,'undef');
-  }
+is (ref(hex(1)), $c);
+is (ref(hex(0x1)), $c);
+is (ref(hex("af")), $c);
+is (hex("af"), Math::BigInt->new(0xaf));
+is (ref(hex("0x1")), $c);
+
+is (ref(oct("0x1")), $c);
+is (ref(oct("01")), $c);
+is (ref(oct("0b01")), $c);
+is (ref(oct("1")), $c);
+is (ref(oct(" 1")), $c);
+is (ref(oct(" 0x1")), $c);
+
+is (ref(oct(0x1)), $c);
+is (ref(oct(01)), $c);
+is (ref(oct(0b01)), $c);
+is (ref(oct(1)), $c);
index 1423b7d..2865453 100644 (file)
@@ -2,94 +2,77 @@
 
 ###############################################################################
 
-use Test;
 use strict;
-
-BEGIN
-  {
-  plan tests => 40;
-  }
+use Test::More tests => 40;
 
 use bigrat qw/oct hex/;
 
 ###############################################################################
 # general tests
 
-my $x = 5; ok (ref($x) =~ /^Math::BigInt/);            # :constant
+my $x = 5; like (ref($x), qr/^Math::BigInt/);          # :constant
 
-# todo:  ok (2 + 2.5,4.5);                             # should still work
-# todo: $x = 2 + 3.5; ok (ref($x),'Math::BigFloat');
+# todo:  is (2 + 2.5,4.5);                             # should still work
+# todo: $x = 2 + 3.5; is (ref($x),'Math::BigFloat');
 
-$x = 2 ** 255; ok (ref($x) =~ /^Math::BigInt/);
+$x = 2 ** 255; like (ref($x), qr/^Math::BigInt/);
 
 # see if Math::BigRat constant works
-ok (1/3, '1/3');
-ok (1/4+1/3,'7/12');
-ok (5/7+3/7,'8/7');
+is (1/3, '1/3');
+is (1/4+1/3,'7/12');
+is (5/7+3/7,'8/7');
 
-ok (3/7+1,'10/7');
-ok (3/7+1.1,'107/70');
-ok (3/7+3/7,'6/7');
+is (3/7+1,'10/7');
+is (3/7+1.1,'107/70');
+is (3/7+3/7,'6/7');
 
-ok (3/7-1,'-4/7');
-ok (3/7-1.1,'-47/70');
-ok (3/7-2/7,'1/7');
+is (3/7-1,'-4/7');
+is (3/7-1.1,'-47/70');
+is (3/7-2/7,'1/7');
 
 # fails ?
-# ok (1+3/7,'10/7');
+# is (1+3/7,'10/7');
 
-ok (1.1+3/7,'107/70');
-ok (3/7*5/7,'15/49');
-ok (3/7 / (5/7),'3/5');
-ok (3/7 / 1,'3/7');
-ok (3/7 / 1.5,'2/7');
+is (1.1+3/7,'107/70');
+is (3/7*5/7,'15/49');
+is (3/7 / (5/7),'3/5');
+is (3/7 / 1,'3/7');
+is (3/7 / 1.5,'2/7');
 
 ###############################################################################
 # accurarcy and precision
 
-ok_undef (bigrat->accuracy());
-ok (bigrat->accuracy(12),12);
-ok (bigrat->accuracy(),12);
+is (bigrat->accuracy(), undef);
+is (bigrat->accuracy(12),12);
+is (bigrat->accuracy(),12);
 
-ok_undef (bigrat->precision());
-ok (bigrat->precision(12),12);
-ok (bigrat->precision(),12);
+is (bigrat->precision(), undef);
+is (bigrat->precision(12),12);
+is (bigrat->precision(),12);
 
-ok (bigrat->round_mode(),'even');
-ok (bigrat->round_mode('odd'),'odd');
-ok (bigrat->round_mode(),'odd');
+is (bigrat->round_mode(),'even');
+is (bigrat->round_mode('odd'),'odd');
+is (bigrat->round_mode(),'odd');
 
 ###############################################################################
 # hex() and oct()
 
 my $c = 'Math::BigInt';
 
-ok (ref(hex(1)), $c);
-ok (ref(hex(0x1)), $c);
-ok (ref(hex("af")), $c);
-ok (hex("af"), Math::BigInt->new(0xaf));
-ok (ref(hex("0x1")), $c);
-
-ok (ref(oct("0x1")), $c);
-ok (ref(oct("01")), $c);
-ok (ref(oct("0b01")), $c);
-ok (ref(oct("1")), $c);
-ok (ref(oct(" 1")), $c);
-ok (ref(oct(" 0x1")), $c);
-
-ok (ref(oct(0x1)), $c);
-ok (ref(oct(01)), $c);
-ok (ref(oct(0b01)), $c);
-ok (ref(oct(1)), $c);
-
-###############################################################################
-###############################################################################
-# Perl 5.005 does not like ok ($x,undef)
-
-sub ok_undef
-  {
-  my $x = shift;
-
-  ok (1,1) and return if !defined $x;
-  ok ($x,'undef');
-  }
+is (ref(hex(1)), $c);
+is (ref(hex(0x1)), $c);
+is (ref(hex("af")), $c);
+is (hex("af"), Math::BigInt->new(0xaf));
+is (ref(hex("0x1")), $c);
+
+is (ref(oct("0x1")), $c);
+is (ref(oct("01")), $c);
+is (ref(oct("0b01")), $c);
+is (ref(oct("1")), $c);
+is (ref(oct(" 1")), $c);
+is (ref(oct(" 0x1")), $c);
+
+is (ref(oct(0x1)), $c);
+is (ref(oct(01)), $c);
+is (ref(oct(0b01)), $c);
+is (ref(oct(1)), $c);
index 3589072..bb9f41f 100644 (file)
@@ -2,13 +2,8 @@
 
 ###############################################################################
 
-use Test;
 use strict;
-
-BEGIN
-  {
-  plan tests => 26;
-  }
+use Test::More tests => 26;
 
 use bigint;
 
index 889bf63..28e38c5 100644 (file)
@@ -2,26 +2,21 @@
 
 ###############################################################################
 
-use Test;
 use strict;
-
-BEGIN
-  {
-  plan tests => 1;
-  }
+use Test::More;
 
 eval 'require Math::BigInt::Lite;';
 if ($@ eq '')
   {
+  plan (tests => 1);
   # can use Lite, so let bignum try it
   require bignum; bignum->import();
   # can't get to work a ref(1+1) here, presumable because :constant phase
   # already done
-  ok ($bignum::_lite,1);
+  is ($bignum::_lite,1);
   }
 else
   {
-  print "ok 1 # skipped, no Math::BigInt::Lite\n";
+  plan skip_all => "no Math::BigInt::Lite";
   }
-  
 
index ca7e21b..45f83b9 100644 (file)
@@ -2,13 +2,8 @@
 
 ###############################################################################
 
-use Test;
 use strict;
-
-BEGIN
-  {
-  plan tests => 26;
-  }
+use Test::More tests => 26;
 
 use bignum;
 
index 524cc26..fd63252 100644 (file)
@@ -2,26 +2,21 @@
 
 ###############################################################################
 
-use Test;
 use strict;
-
-BEGIN
-  {
-  plan tests => 1;
-  }
+use Test::More;
 
 eval 'require Math::BigInt::Lite;';
 if ($@ eq '')
   {
+  plan (tests => 1);
   # can use Lite, so let bignum try it
   require bigrat; bigrat->import();
   # can't get to work a ref(1+1) here, presumable because :constant phase
   # already done
-  ok ($bigrat::_lite,1);
+  is ($bigrat::_lite,1);
   }
 else
   {
-  print "ok 1 # skipped, no Math::BigInt::Lite\n";
+  plan (skip_all =>  "no Math::BigInt::Lite");
   }
-  
 
index c79b814..ce7daa1 100644 (file)
@@ -2,13 +2,8 @@
 
 ###############################################################################
 
-use Test;
 use strict;
-
-BEGIN
-  {
-  plan tests => 26;
-  }
+use Test::More tests => 26;
 
 use bigrat;
 
index 771b94e..561adc1 100644 (file)
@@ -6,30 +6,30 @@ my ($x);
 ###############################################################################
 # inf tests
 
-$x = 1+inf;    ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'inf');
-$x = 1*inf;    ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'inf');
+$x = 1+inf;    like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'inf');
+$x = 1*inf;    like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'inf');
 
 # these don't work without exporting inf()
-$x = inf;      ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'inf');
-$x = inf+inf;  ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'inf');
-$x = inf*inf;  ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'inf');
+$x = inf;      like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'inf');
+$x = inf+inf;  like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'inf');
+$x = inf*inf;  like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'inf');
 
 ###############################################################################
 # NaN tests
 
-$x = 1+NaN;    ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'NaN');
-$x = 1*NaN;    ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'NaN');
+$x = 1+NaN;    like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'NaN');
+$x = 1*NaN;    like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'NaN');
 
 # these don't work without exporting NaN()
-$x = NaN;      ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'NaN');
-$x = NaN+NaN;  ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'NaN');
-$x = NaN*NaN;  ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'NaN');
+$x = NaN;      like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'NaN');
+$x = NaN+NaN;  like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'NaN');
+$x = NaN*NaN;  like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'NaN');
 
 ###############################################################################
 # mixed tests
 
 # these don't work without exporting NaN() or inf()
-$x = NaN+inf;  ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'NaN');
-$x = NaN*inf;  ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'NaN');
-$x = inf*NaN;  ok (ref($x) =~ /^Math::BigInt/); ok ($x->bstr(),'NaN');
+$x = NaN+inf;  like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'NaN');
+$x = NaN*inf;  like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'NaN');
+$x = inf*NaN;  like (ref($x), qr/^Math::BigInt/); is ($x->bstr(),'NaN');