Also compare correctness in release mode by replacing Assert by AssertThrow

git-svn-id: https://svn.dealii.org/trunk@32785 0785d39b-7218-0410-832d-ea1e28bc413d

diff --git a/tests/base/vectorization_01.cc b/tests/base/vectorization_01.cc
index bb2e43046f2e250f90d2ef0a32b012887adcb11b..4d02ddaddab5efceae302cd77e8b32f6a5fa11fa 100644 (file)
--- a/tests/base/vectorization_01.cc
+++ b/tests/base/vectorization_01.cc
@@ -39,54 +39,54 @@ void test ()
   deallog << "Addition: ";
   VectorizedArray<Number> d = a + b;
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == 1, ExcInternalError());
+    AssertThrow (d[i] == 1, ExcInternalError());
   deallog << "OK" << std::endl
           << "Subtraction: ";
   VectorizedArray<Number> e = d - b;
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (e[i] == a[i], ExcInternalError());
+    AssertThrow (e[i] == a[i], ExcInternalError());
   deallog << "OK" << std::endl
           << "Multiplication: ";
   d = a * c;
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == a[i] * c[i], ExcInternalError());
+    AssertThrow (d[i] == a[i] * c[i], ExcInternalError());
   deallog << "OK" << std::endl
           << "Division: ";
   e = d / a;
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (e[i] == c[i], ExcInternalError());
+    AssertThrow (e[i] == c[i], ExcInternalError());
   deallog << "OK" << std::endl
           << "Multiplication scalar: ";
   a = 2. * a;
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (a[i] == 4., ExcInternalError());
+    AssertThrow (a[i] == 4., ExcInternalError());
   deallog << "OK" << std::endl
           << "Division scalar left: ";
   d = 1. / a;
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == 0.25, ExcInternalError());
+    AssertThrow (d[i] == 0.25, ExcInternalError());
   deallog << "OK" << std::endl
           << "Division scalar right: ";
   e = d / 0.25;
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (e[i] == 1, ExcInternalError());
+    AssertThrow (e[i] == 1, ExcInternalError());
   deallog << "OK" << std::endl
           << "Unary operator -: ";
   d = -c;
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == -(Number)i, ExcInternalError());
+    AssertThrow (d[i] == -(Number)i, ExcInternalError());
   deallog << "OK" << std::endl
           << "Unary operator +: ";
   d = c;
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == i, ExcInternalError());
+    AssertThrow (d[i] == i, ExcInternalError());
 
 
   deallog << "OK" << std::endl
           << "Square root: ";
   d = std::sqrt(c);
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (std::fabs(d[i]-std::sqrt(Number(i)))<
+    AssertThrow (std::fabs(d[i]-std::sqrt(Number(i)))<
             std::numeric_limits<Number>::epsilon(),
             ExcInternalError());
 
@@ -95,53 +95,54 @@ void test ()
   d = -c;
   d = std::abs(d);
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == Number(i), ExcInternalError());
+    AssertThrow (d[i] == Number(i), ExcInternalError());
   deallog << "OK" << std::endl
           << "Maximum value: ";
   d = std::max(a, c);
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == std::max(a[i], c[i]), ExcInternalError());
+    AssertThrow (d[i] == std::max(a[i], c[i]), ExcInternalError());
   deallog << "OK" << std::endl
           << "Minimum value: ";
   d = std::min(0.5 * a + b, c);
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == std::min(Number(0.5 * a[i] + b[i]), c[i]), ExcInternalError());
+    AssertThrow (d[i] == std::min(Number(0.5 * a[i] + b[i]), c[i]),
+                 ExcInternalError());
 
   deallog << "OK" << std::endl
           << "Sine: ";
   e = std::sin(b);
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (std::fabs(e[i]-std::sin(b[i])) <
-            10.*std::numeric_limits<Number>::epsilon(),
-            ExcInternalError());
+    AssertThrow (std::fabs(e[i]-std::sin(b[i])) <
+                 10.*std::numeric_limits<Number>::epsilon(),
+                 ExcInternalError());
   deallog << "OK" << std::endl
           << "Cosine: ";
   e = std::cos(c);
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (std::fabs(e[i]-std::cos(c[i])) <
-            10.*std::numeric_limits<Number>::epsilon(),
-            ExcInternalError());
+    AssertThrow (std::fabs(e[i]-std::cos(c[i])) <
+                 10.*std::numeric_limits<Number>::epsilon(),
+                 ExcInternalError());
   deallog << "OK" << std::endl
           << "Tangent: ";
   d = std::tan(e);
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (std::fabs(d[i]-std::tan(e[i])) <
-            10.*std::numeric_limits<Number>::epsilon(),
-            ExcInternalError());
+    AssertThrow (std::fabs(d[i]-std::tan(e[i])) <
+                 10.*std::numeric_limits<Number>::epsilon(),
+                 ExcInternalError());
   deallog << "OK" << std::endl
           << "Exponential: ";
   d = std::exp(c-a);
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (std::fabs(d[i]-std::exp(c[i]-a[i])) <
-            10.*std::numeric_limits<Number>::epsilon(),
-            ExcInternalError());
+    AssertThrow (std::fabs(d[i]-std::exp(c[i]-a[i])) <
+                 10.*std::numeric_limits<Number>::epsilon(),
+                 ExcInternalError());
   deallog << "OK" << std::endl
           << "Logarithm: ";
   e = std::log(d);
   for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (std::fabs(e[i]-(c[i]-a[i])) <
-            10.*std::numeric_limits<Number>::epsilon(),
-            ExcInternalError());
+    AssertThrow (std::fabs(e[i]-(c[i]-a[i])) <
+                 10.*std::numeric_limits<Number>::epsilon(),
+                 ExcInternalError());
   deallog << "OK" << std::endl;
 }
 

diff --git a/tests/base/vectorization_02.cc b/tests/base/vectorization_02.cc
index 19ecfd625db584c35a174248c0dd5d29a1925fc4..1e3f4fc0e6d4553db8c8edac64fdb6d65c73bb53 100644 (file)
--- a/tests/base/vectorization_02.cc
+++ b/tests/base/vectorization_02.cc
@@ -35,7 +35,7 @@ void test ()
   deallog << "Constructor: ";
   for (unsigned int i=0; i<a.size(); ++i)
     for (unsigned int d=0; d<n_vectors; ++d)
-      Assert (a[i][d] == 0, ExcInternalError());
+      AssertThrow (a[i][d] == 0, ExcInternalError());
   deallog << "OK" << std::endl;
 
   a[2] = 1;
@@ -57,21 +57,21 @@ void test ()
   deallog << "Insertion: ";
   for (unsigned int i=0; i<a.size(); ++i)
     for (unsigned int d=0; d<n_vectors; ++d)
-      Assert (a[i][d] == a_ref[i], ExcInternalError());
+      AssertThrow (a[i][d] == a_ref[i], ExcInternalError());
   deallog << "OK" << std::endl;
 
   a.resize(4);
   deallog << "Shrinking: ";
   for (unsigned int i=0; i<a.size(); ++i)
     for (unsigned int d=0; d<n_vectors; ++d)
-      Assert (a[i][d] == a_ref[i], ExcInternalError());
+      AssertThrow (a[i][d] == a_ref[i], ExcInternalError());
   deallog << "OK" << std::endl;
 
   a.reserve(100);
   deallog << "Reserve: ";
   for (unsigned int i=0; i<a.size(); ++i)
     for (unsigned int d=0; d<n_vectors; ++d)
-      Assert (a[i][d] == a_ref[i], ExcInternalError());
+      AssertThrow (a[i][d] == a_ref[i], ExcInternalError());
   deallog << "OK" << std::endl;
 
   a = b;
@@ -79,7 +79,7 @@ void test ()
   deallog << "Assignment: ";
   for (unsigned int i=0; i<a.size(); ++i)
     for (unsigned int d=0; d<n_vectors; ++d)
-      Assert (a[i][d] == a_ref[i], ExcInternalError());
+      AssertThrow (a[i][d] == a_ref[i], ExcInternalError());
   deallog << "OK" << std::endl;
 
   // check setting elements for large vectors
@@ -88,7 +88,7 @@ void test ()
   deallog << "Check large initialization: ";
   for (unsigned int i=0; i<100000; ++i)
     for (unsigned int d=0; d<n_vectors; ++d)
-      Assert (a[i][d] == 1., ExcInternalError());
+      AssertThrow (a[i][d] == 1., ExcInternalError());
   deallog << "OK" << std::endl;
 
   // check resize for large vectors
@@ -97,13 +97,13 @@ void test ()
   a.resize (400000);
   for (unsigned int i=0; i<100000; ++i)
     for (unsigned int d=0; d<n_vectors; ++d)
-      Assert (a[i][d] == 1., ExcInternalError());
+      AssertThrow (a[i][d] == 1., ExcInternalError());
   for (unsigned int i=100000; i<200000; ++i)
     for (unsigned int d=0; d<n_vectors; ++d)
-      Assert (a[i][d] == 2., ExcInternalError());
+      AssertThrow (a[i][d] == 2., ExcInternalError());
   for (unsigned int i=200000; i<400000; ++i)
     for (unsigned int d=0; d<n_vectors; ++d)
-      Assert (a[i][d] == 0., ExcInternalError());
+      AssertThrow (a[i][d] == 0., ExcInternalError());
   deallog << "OK" << std::endl;
 }