Rework bigunsignedinttest.cc.

dune/common/test/bigunsignedinttest.cc

@@ -4,73 +4,89 @@
 #include "config.h"
 #endif
 
+#include <cstdint>
 #include <limits>
 #include <iostream>
 
 #include <dune/common/bigunsignedint.hh>
 #include <dune/common/hash.hh>
 
+#define CHECK(x) \
+  do { \
+    if (!(x)) { \
+      pass = false; \
+      std::cerr << "FAILED: " << #x << std::endl; \
+    } \
+  } while(false)
+
 int main()
 {
+  bool pass = true;
+
+  typedef Dune::bigunsignedint<16> ShortInteger;
+  typedef Dune::bigunsignedint<128> BigInteger;
+
+  /* Test std::numeric_limits for ShortInteger (should be same as for uint16_t) */
+  CHECK(std::numeric_limits<ShortInteger>::min() == std::numeric_limits<std::uint16_t>::min());
+  CHECK(std::numeric_limits<ShortInteger>::max() == std::numeric_limits<std::uint16_t>::max());
+  CHECK(std::numeric_limits<ShortInteger>::digits == std::numeric_limits<std::uint16_t>::digits);
+  CHECK(std::numeric_limits<ShortInteger>::epsilon() == std::numeric_limits<std::uint16_t>::epsilon());
+  CHECK(std::numeric_limits<ShortInteger>::round_error() == std::numeric_limits<std::uint16_t>::round_error());
+
+  CHECK(std::numeric_limits<ShortInteger>::is_exact);
+  CHECK(std::numeric_limits<ShortInteger>::is_integer);
+  CHECK(!std::numeric_limits<ShortInteger>::is_signed);
 
-  std::cout<<"unsigned short: max="<<std::numeric_limits<unsigned short>::max()
-           <<" min="<<std::numeric_limits<unsigned short>::min()
-           <<" digits="<<std::numeric_limits<unsigned short>::digits<<std::endl;
-  std::cout<<"int: max="<<std::numeric_limits<int>::max()<<" min="
-           <<std::numeric_limits<int>::min()<<" digits="
-           <<std::numeric_limits<int>::digits<<std::endl;
-  std::cout<<"unsigned int: max="<<std::numeric_limits<unsigned int>::max()
-           <<" min="<<std::numeric_limits<unsigned int>::min()<<" digits="
-           <<std::numeric_limits<unsigned int>::digits<<" digits10="
-           <<std::numeric_limits<unsigned int>::digits10<<" radix="
-           <<std::numeric_limits<unsigned int>::radix<<" eps="
-           <<std::numeric_limits<unsigned int>::epsilon()
-           <<" round_error="
-           <<std::numeric_limits<unsigned int>::round_error()
-           <<" min_exponent="
-           <<std::numeric_limits<unsigned int>::min_exponent
-           <<" float_denorm_style="
-           <<std::numeric_limits<unsigned int>::has_denorm
-           <<" traps="<<std::numeric_limits<unsigned int>::traps
-           <<std::endl;
-  std::cout<<"bigunsignedint: max="<<std::numeric_limits<Dune::bigunsignedint<32> >::max()
-           <<" min="<<std::numeric_limits<Dune::bigunsignedint<32> >::min()<<" digits="<<std::numeric_limits<Dune::bigunsignedint<32> >::digits<<std::endl;
-  std::cout<<"bigunsignedint: max="<<std::numeric_limits<Dune::bigunsignedint<100> >::max()
-           <<" min="<<std::numeric_limits<Dune::bigunsignedint<100> >::min()<<" digits="<<std::numeric_limits<Dune::bigunsignedint<100> >::digits
-           <<" traps="<<std::numeric_limits<Dune::bigunsignedint<100> >::traps
-           <<std::endl;
-
-  int a1, b1, c1;
-  a1=100;
-  b1=3;
-  c1=a1/b1;
-  std::cout<<a1<<"/"<<b1<<"="<<c1<<std::endl;
-
-
-  Dune::bigunsignedint<100> a, b, c;
-  a=100;
-  b=3;
-  c=a/b;
-  std::cout<<a<<"/"<<b<<"="<<c<<std::endl;
-
-  try{
-
-    a=100;
-    b=0;
-    c=a/1;
-    std::cout<<a1<<"/"<<b1<<"="<<c1<<std::endl;
-    a=1000000;
-    std::cout<<a.todouble()<<std::endl;
-    std::cout<<a.touint()<<std::endl;
-    b=a;
-    a=a*b*b;
-    std::cout<<a.todouble()<<std::endl;
-
-    Dune::hash<Dune::bigunsignedint<100> > hasher;
-    std::cout << "Dune::hash:     " << hasher(a) << std::endl;
+  /* Test std::numeric_limits for BigInteger */
+  CHECK(std::numeric_limits<BigInteger>::min() == 0u);
+  CHECK(std::numeric_limits<BigInteger>::digits == 128);
+  CHECK(std::numeric_limits<BigInteger>::epsilon() == 0u);
+  CHECK(std::numeric_limits<BigInteger>::round_error() == 0u);
 
+  CHECK(std::numeric_limits<BigInteger>::is_exact);
+  CHECK(std::numeric_limits<BigInteger>::is_integer);
+  CHECK(!std::numeric_limits<BigInteger>::is_signed);
+
+  /* Test constructor */
+  CHECK(BigInteger(10u) == 10u);
+  CHECK(BigInteger(10) == BigInteger(10u));
+
+  try {
+    BigInteger tmp(-10);
+    pass = false;
+    std::cerr << "FAILED: BigInteger(-10) should throw an exception." << std::endl;
+  }
+  catch(const Dune::Exception&) {
+    /* Ignore */
   }
-  catch(Dune::MathError e) {
-    std::cout<<e<<std::endl;
+  catch(...) {
+    pass = false;
+    std::cerr << "FAILED: BigInteger(-10) threw an unexpected exception." << std::endl;
   }
+
+  /* Test conversion */
+  CHECK(BigInteger(10u).touint() == 10u);
+  CHECK(BigInteger(10u).todouble() == 10.0);
+
+  /* Check BigInteger arithmetic */
+  CHECK(BigInteger(10u) + BigInteger(3u) == BigInteger(10u + 3u));
+  CHECK(BigInteger(10u) - BigInteger(3u) == BigInteger(10u - 3u));
+  CHECK(BigInteger(10u) * BigInteger(3u) == BigInteger(10u * 3u));
+  CHECK(BigInteger(10u) / BigInteger(3u) == BigInteger(10u / 3u));
+  CHECK(BigInteger(10u) % BigInteger(3u) == BigInteger(10u % 3u));
+
+  CHECK(BigInteger(100000u) + BigInteger(30000u) == BigInteger(100000u + 30000u));
+  CHECK(BigInteger(100000u) - BigInteger(30000u) == BigInteger(100000u - 30000u));
+  CHECK(BigInteger(70000u) - BigInteger(30000u) == BigInteger(70000u - 30000u));
+  CHECK(BigInteger(100000u) * BigInteger(30000u) == BigInteger(100000u * 30000u));
+  CHECK(BigInteger(100000u) / BigInteger(30000u) == BigInteger(100000u / 30000u));
+  CHECK(BigInteger(100000u) % BigInteger(30000u) == BigInteger(100000u % 30000u));
+
+  /* Test hashing */
+  {
+    Dune::hash<BigInteger> hasher;
+    CHECK(hasher(BigInteger(100)) == hasher(BigInteger(100)));
+  }
+
+  return pass ? 0 : 1;
 }