Fix "catching polymorphic type by value" warnings (#2556)

When using the `TS_ASSERT_THROWS` marco from CxxTest, we have to make
sure that we use a reference type for the exception, otherwise the unit
test tries to catch the exception by value, resulting in "catching
polymorphic type by value" warnings.

7 files changed, 66 insertions, 57 deletions

diff --git a/test/unit/util/array_store_all_black.h b/test/unit/util/array_store_all_black.h
index c668e8c8f..21274389b 100644
--- a/test/unit/util/array_store_all_black.h
+++ b/test/unit/util/array_store_all_black.h
@@ -67,7 +67,7 @@ class ArrayStoreAllBlack : public CxxTest::TestSuite {
     TS_ASSERT_THROWS(
         ArrayStoreAll(d_em->mkArrayType(d_em->integerType(), d_em->mkSort("U")),
                       d_em->mkConst(Rational(9, 2))),
-        IllegalArgumentException);
+        IllegalArgumentException&);
   }
 
   void testConstError() {
diff --git a/test/unit/util/assert_white.h b/test/unit/util/assert_white.h
index 41d97b65b..e45d15296 100644
--- a/test/unit/util/assert_white.h
+++ b/test/unit/util/assert_white.h
@@ -29,22 +29,22 @@ public:
 
   void testAssert() {
 #ifdef CVC4_ASSERTIONS
-    TS_ASSERT_THROWS( Assert(false), AssertionException );
-    TS_ASSERT_THROWS( AssertArgument(false, "x"), AssertArgumentException );
+    TS_ASSERT_THROWS(Assert(false), AssertionException&);
+    TS_ASSERT_THROWS(AssertArgument(false, "x"), AssertArgumentException&);
 #else /* CVC4_ASSERTIONS */
     TS_ASSERT_THROWS_NOTHING( Assert(false) );
     TS_ASSERT_THROWS_NOTHING( AssertArgument(false, "x") );
 #endif /* CVC4_ASSERTIONS */
 
     TS_ASSERT_THROWS_NOTHING( Assert(true) );
-    TS_ASSERT_THROWS( AlwaysAssert(false), AssertionException );
-    TS_ASSERT_THROWS( Unreachable(), UnreachableCodeException );
-    TS_ASSERT_THROWS( Unhandled(), UnhandledCaseException );
-    TS_ASSERT_THROWS( Unimplemented(), UnimplementedOperationException );
-    TS_ASSERT_THROWS( IllegalArgument("x"), IllegalArgumentException );
-    TS_ASSERT_THROWS( CheckArgument(false, "x"), IllegalArgumentException );
-    TS_ASSERT_THROWS( AlwaysAssertArgument(false, "x"),
-                      AssertArgumentException );
+    TS_ASSERT_THROWS(AlwaysAssert(false), AssertionException&);
+    TS_ASSERT_THROWS(Unreachable(), UnreachableCodeException&);
+    TS_ASSERT_THROWS(Unhandled(), UnhandledCaseException&);
+    TS_ASSERT_THROWS(Unimplemented(), UnimplementedOperationException&);
+    TS_ASSERT_THROWS(IllegalArgument("x"), IllegalArgumentException&);
+    TS_ASSERT_THROWS(CheckArgument(false, "x"), IllegalArgumentException&);
+    TS_ASSERT_THROWS(AlwaysAssertArgument(false, "x"),
+                     AssertArgumentException&);
     TS_ASSERT_THROWS_NOTHING( AssertArgument(true, "x") );
     TS_ASSERT_THROWS_NOTHING( AssertArgument(true, "x") );
   }
@@ -99,15 +99,16 @@ public:
   }
 
   void testUnreachable() {
-    TS_ASSERT_THROWS( Unreachable(), UnreachableCodeException );
-    TS_ASSERT_THROWS( Unreachable("hello"), UnreachableCodeException );
-    TS_ASSERT_THROWS( Unreachable("hello %s", "world"), UnreachableCodeException );
+    TS_ASSERT_THROWS(Unreachable(), UnreachableCodeException&);
+    TS_ASSERT_THROWS(Unreachable("hello"), UnreachableCodeException&);
+    TS_ASSERT_THROWS(Unreachable("hello %s", "world"),
+                     UnreachableCodeException&);
 
     int x = 5;
-    TS_ASSERT_THROWS( Unhandled(), UnhandledCaseException );
-    TS_ASSERT_THROWS( Unhandled(x), UnhandledCaseException );
-    TS_ASSERT_THROWS( Unhandled("foo"), UnhandledCaseException );
-    TS_ASSERT_THROWS( Unhandled("foo %s baz", "bar"), UnhandledCaseException );
+    TS_ASSERT_THROWS(Unhandled(), UnhandledCaseException&);
+    TS_ASSERT_THROWS(Unhandled(x), UnhandledCaseException&);
+    TS_ASSERT_THROWS(Unhandled("foo"), UnhandledCaseException&);
+    TS_ASSERT_THROWS(Unhandled("foo %s baz", "bar"), UnhandledCaseException&);
   }
 
 };
diff --git a/test/unit/util/bitvector_black.h b/test/unit/util/bitvector_black.h
index c75368196..1446008e6 100644
--- a/test/unit/util/bitvector_black.h
+++ b/test/unit/util/bitvector_black.h
@@ -93,8 +93,8 @@ public:
     BitVector b = one.concat(zero);
     TS_ASSERT_EQUALS(b.toString(), "00010000");
     TS_ASSERT_EQUALS(b.extract(7, 4), one);
-    TS_ASSERT_THROWS(b.extract(4, 7), IllegalArgumentException);
-    TS_ASSERT_THROWS(b.extract(8, 3), IllegalArgumentException);
+    TS_ASSERT_THROWS(b.extract(4, 7), IllegalArgumentException&);
+    TS_ASSERT_THROWS(b.extract(8, 3), IllegalArgumentException&);
     TS_ASSERT_EQUALS(b.concat(BitVector()), b);
   }
 
@@ -116,10 +116,10 @@ public:
     TS_ASSERT(negOne.signedLessThanEq(negOne));
 
     BitVector b = negOne.concat(negOne);
-    TS_ASSERT_THROWS(b.unsignedLessThan(negOne), IllegalArgumentException);
-    TS_ASSERT_THROWS(negOne.unsignedLessThanEq(b), IllegalArgumentException);
-    TS_ASSERT_THROWS(b.signedLessThan(negOne), IllegalArgumentException);
-    TS_ASSERT_THROWS(negOne.signedLessThanEq(b), IllegalArgumentException);
+    TS_ASSERT_THROWS(b.unsignedLessThan(negOne), IllegalArgumentException&);
+    TS_ASSERT_THROWS(negOne.unsignedLessThanEq(b), IllegalArgumentException&);
+    TS_ASSERT_THROWS(b.signedLessThan(negOne), IllegalArgumentException&);
+    TS_ASSERT_THROWS(negOne.signedLessThanEq(b), IllegalArgumentException&);
   }
 
   void testBitwiseOps()
@@ -145,10 +145,10 @@ public:
     TS_ASSERT_EQUALS(negOne.unsignedRemTotal(two), one);
 
     BitVector b = negOne.concat(negOne);
-    TS_ASSERT_THROWS(b + negOne, IllegalArgumentException);
-    TS_ASSERT_THROWS(negOne * b, IllegalArgumentException);
-    TS_ASSERT_THROWS(b.unsignedDivTotal(negOne), IllegalArgumentException);
-    TS_ASSERT_THROWS(negOne.unsignedRemTotal(b), IllegalArgumentException);
+    TS_ASSERT_THROWS(b + negOne, IllegalArgumentException&);
+    TS_ASSERT_THROWS(negOne * b, IllegalArgumentException&);
+    TS_ASSERT_THROWS(b.unsignedDivTotal(negOne), IllegalArgumentException&);
+    TS_ASSERT_THROWS(negOne.unsignedRemTotal(b), IllegalArgumentException&);
   }
 
   void testExtendOps()
diff --git a/test/unit/util/boolean_simplification_black.h b/test/unit/util/boolean_simplification_black.h
index 2654c1c07..445103407 100644
--- a/test/unit/util/boolean_simplification_black.h
+++ b/test/unit/util/boolean_simplification_black.h
@@ -130,7 +130,8 @@ public:
 
 #ifdef CVC4_ASSERTIONS
     in = Node();
-    TS_ASSERT_THROWS( BooleanSimplification::negate(in), AssertArgumentException );
+    TS_ASSERT_THROWS(BooleanSimplification::negate(in),
+                     AssertArgumentException&);
 #endif /* CVC4_ASSERTIONS */
   }
 
@@ -165,7 +166,8 @@ public:
 
 #ifdef CVC4_ASSERTIONS
     in = d_nm->mkNode(kind::AND, a, b);
-    TS_ASSERT_THROWS( BooleanSimplification::simplifyClause(in), AssertArgumentException );
+    TS_ASSERT_THROWS(BooleanSimplification::simplifyClause(in),
+                     AssertArgumentException&);
 #endif /* CVC4_ASSERTIONS */
   }
 
@@ -190,7 +192,8 @@ public:
 
 #ifdef CVC4_ASSERTIONS
     in = d_nm->mkNode(kind::OR, a, b);
-    TS_ASSERT_THROWS( BooleanSimplification::simplifyHornClause(in), AssertArgumentException );
+    TS_ASSERT_THROWS(BooleanSimplification::simplifyHornClause(in),
+                     AssertArgumentException&);
 #endif /* CVC4_ASSERTIONS */
   }
 
@@ -211,7 +214,8 @@ public:
 
 #ifdef CVC4_ASSERTIONS
     in = d_nm->mkNode(kind::OR, a, b);
-    TS_ASSERT_THROWS( BooleanSimplification::simplifyConflict(in), AssertArgumentException );
+    TS_ASSERT_THROWS(BooleanSimplification::simplifyConflict(in),
+                     AssertArgumentException&);
 #endif /* CVC4_ASSERTIONS */
   }
 
diff --git a/test/unit/util/cardinality_public.h b/test/unit/util/cardinality_public.h
index 449a88946..ee4a23fd3 100644
--- a/test/unit/util/cardinality_public.h
+++ b/test/unit/util/cardinality_public.h
@@ -34,9 +34,11 @@ public:
     Cardinality two(2);
 
     Cardinality invalid(0);
-    TS_ASSERT_THROWS( invalid = Cardinality(-1), IllegalArgumentException);
-    TS_ASSERT_THROWS( invalid = Cardinality(-2), IllegalArgumentException);
-    TS_ASSERT_THROWS( invalid = Cardinality(Integer("-3983982192391747295721957")), IllegalArgumentException);
+    TS_ASSERT_THROWS(invalid = Cardinality(-1), IllegalArgumentException&);
+    TS_ASSERT_THROWS(invalid = Cardinality(-2), IllegalArgumentException&);
+    TS_ASSERT_THROWS(
+        invalid = Cardinality(Integer("-3983982192391747295721957")),
+        IllegalArgumentException&);
     invalid = one; // test assignment
     invalid = Cardinality(5); // test assignment to temporary
 
@@ -121,16 +123,16 @@ public:
     TS_ASSERT( two.getFiniteCardinality() == 2 );
     TS_ASSERT( copy.getFiniteCardinality() == 1 );
     TS_ASSERT( invalid.getFiniteCardinality() == 5 );
-    TS_ASSERT_THROWS( big.getFiniteCardinality(), IllegalArgumentException );
-    TS_ASSERT_THROWS( i.getFiniteCardinality(), IllegalArgumentException );
-    TS_ASSERT_THROWS( r.getFiniteCardinality(), IllegalArgumentException );
-
-    TS_ASSERT_THROWS( zero.getBethNumber(), IllegalArgumentException );
-    TS_ASSERT_THROWS( one.getBethNumber(), IllegalArgumentException );
-    TS_ASSERT_THROWS( two.getBethNumber(), IllegalArgumentException );
-    TS_ASSERT_THROWS( copy.getBethNumber(), IllegalArgumentException );
-    TS_ASSERT_THROWS( invalid.getBethNumber(), IllegalArgumentException );
-    TS_ASSERT_THROWS( big.getBethNumber(), IllegalArgumentException );
+    TS_ASSERT_THROWS(big.getFiniteCardinality(), IllegalArgumentException&);
+    TS_ASSERT_THROWS(i.getFiniteCardinality(), IllegalArgumentException&);
+    TS_ASSERT_THROWS(r.getFiniteCardinality(), IllegalArgumentException&);
+
+    TS_ASSERT_THROWS(zero.getBethNumber(), IllegalArgumentException&);
+    TS_ASSERT_THROWS(one.getBethNumber(), IllegalArgumentException&);
+    TS_ASSERT_THROWS(two.getBethNumber(), IllegalArgumentException&);
+    TS_ASSERT_THROWS(copy.getBethNumber(), IllegalArgumentException&);
+    TS_ASSERT_THROWS(invalid.getBethNumber(), IllegalArgumentException&);
+    TS_ASSERT_THROWS(big.getBethNumber(), IllegalArgumentException&);
     TS_ASSERT( i.getBethNumber() == 0 );
     TS_ASSERT( r.getBethNumber() == 1 );
 
@@ -211,7 +213,7 @@ public:
     TS_ASSERT( x.compare(y) == Cardinality::LESS );
     TS_ASSERT( y.compare(z) == Cardinality::LESS );
 
-    TS_ASSERT_THROWS( big.getBethNumber(), IllegalArgumentException );
+    TS_ASSERT_THROWS(big.getBethNumber(), IllegalArgumentException&);
     TS_ASSERT( x.getBethNumber() == 0 );
     TS_ASSERT( y.getBethNumber() == 1 );
     TS_ASSERT( z.getBethNumber() == 2 );
diff --git a/test/unit/util/datatype_black.h b/test/unit/util/datatype_black.h
index c2086c415..160f25e6f 100644
--- a/test/unit/util/datatype_black.h
+++ b/test/unit/util/datatype_black.h
@@ -70,8 +70,9 @@ class DatatypeBlack : public CxxTest::TestSuite {
     const Datatype& colorsDT = colorsType.getDatatype();
     TS_ASSERT(colorsDT.getConstructor("blue") == ctor);
     TS_ASSERT(colorsDT["blue"].getConstructor() == ctor);
-    TS_ASSERT_THROWS(colorsDT["blue"].getSelector("foo"), IllegalArgumentException);
-    TS_ASSERT_THROWS(colorsDT["blue"]["foo"], IllegalArgumentException);
+    TS_ASSERT_THROWS(colorsDT["blue"].getSelector("foo"),
+                     IllegalArgumentException&);
+    TS_ASSERT_THROWS(colorsDT["blue"]["foo"], IllegalArgumentException&);
 
     TS_ASSERT(! colorsType.getDatatype().isParametric());
     TS_ASSERT(colorsType.getDatatype().isFinite());
@@ -130,7 +131,8 @@ class DatatypeBlack : public CxxTest::TestSuite {
     Expr ctor = treeType.getDatatype()[1].getConstructor();
     TS_ASSERT(treeType.getConstructor("leaf") == ctor);
     TS_ASSERT(treeType.getConstructor("leaf") == ctor);
-    TS_ASSERT_THROWS(treeType.getConstructor("leff"), IllegalArgumentException);
+    TS_ASSERT_THROWS(treeType.getConstructor("leff"),
+                     IllegalArgumentException&);
 
     TS_ASSERT(! treeType.getDatatype().isParametric());
     TS_ASSERT(! treeType.getDatatype().isFinite());
diff --git a/test/unit/util/integer_black.h b/test/unit/util/integer_black.h
index 6c183c972..9297429b4 100644
--- a/test/unit/util/integer_black.h
+++ b/test/unit/util/integer_black.h
@@ -293,14 +293,14 @@ public:
   }
 
   void testParseErrors() {
-    TS_ASSERT_THROWS(Integer("abracadabra"), std::invalid_argument);
-    TS_ASSERT_THROWS(Integer("+-1"), std::invalid_argument);
-    TS_ASSERT_THROWS(Integer("-+1"), std::invalid_argument);
-    TS_ASSERT_THROWS(Integer("5i"), std::invalid_argument);
-    TS_ASSERT_THROWS(Integer("10xyz"), std::invalid_argument);
-    TS_ASSERT_THROWS(Integer("0xff", 10), std::invalid_argument);
-    TS_ASSERT_THROWS(Integer("#x5", 0), std::invalid_argument);
-    TS_ASSERT_THROWS(Integer("0b123", 0), std::invalid_argument);
+    TS_ASSERT_THROWS(Integer("abracadabra"), std::invalid_argument&);
+    TS_ASSERT_THROWS(Integer("+-1"), std::invalid_argument&);
+    TS_ASSERT_THROWS(Integer("-+1"), std::invalid_argument&);
+    TS_ASSERT_THROWS(Integer("5i"), std::invalid_argument&);
+    TS_ASSERT_THROWS(Integer("10xyz"), std::invalid_argument&);
+    TS_ASSERT_THROWS(Integer("0xff", 10), std::invalid_argument&);
+    TS_ASSERT_THROWS(Integer("#x5", 0), std::invalid_argument&);
+    TS_ASSERT_THROWS(Integer("0b123", 0), std::invalid_argument&);
   }
 
   void testPow() {