⬆ updated to Catch 2.0.1

Update required all CHECK_THROWS_AS macros to pass the exception type without reference, because this is now done by Catch2.

test/src/unit-algorithms.cpp

@@ -240,7 +240,7 @@ TEST_CASE("algorithms")
             SECTION("sorting an object")
             {
                 json j({{"one", 1}, {"two", 2}});
-                CHECK_THROWS_AS(std::sort(j.begin(), j.end()), json::invalid_iterator&);
+                CHECK_THROWS_AS(std::sort(j.begin(), j.end()), json::invalid_iterator);
                 CHECK_THROWS_WITH(std::sort(j.begin(), j.end()),
                                   "[json.exception.invalid_iterator.209] cannot use offsets with object iterators");
             }

test/src/unit-allocator.cpp

@@ -59,7 +59,7 @@ TEST_CASE("bad_alloc")
               bad_allocator>;
 
         // creating an object should throw
-        CHECK_THROWS_AS(bad_json(bad_json::value_t::object), std::bad_alloc&);
+        CHECK_THROWS_AS(bad_json(bad_json::value_t::object), std::bad_alloc);
     }
 }
 
@@ -143,7 +143,7 @@ TEST_CASE("controlled bad_alloc")
                 auto t = my_json::value_t::object;
                 CHECK_NOTHROW(my_allocator_clean_up(my_json::json_value(t).object));
                 next_construct_fails = true;
-                CHECK_THROWS_AS(my_json::json_value(t), std::bad_alloc&);
+                CHECK_THROWS_AS(my_json::json_value(t), std::bad_alloc);
                 next_construct_fails = false;
             }
             SECTION("array")
@@ -152,7 +152,7 @@ TEST_CASE("controlled bad_alloc")
                 auto t = my_json::value_t::array;
                 CHECK_NOTHROW(my_allocator_clean_up(my_json::json_value(t).array));
                 next_construct_fails = true;
-                CHECK_THROWS_AS(my_json::json_value(t), std::bad_alloc&);
+                CHECK_THROWS_AS(my_json::json_value(t), std::bad_alloc);
                 next_construct_fails = false;
             }
             SECTION("string")
@@ -161,7 +161,7 @@ TEST_CASE("controlled bad_alloc")
                 auto t = my_json::value_t::string;
                 CHECK_NOTHROW(my_allocator_clean_up(my_json::json_value(t).string));
                 next_construct_fails = true;
-                CHECK_THROWS_AS(my_json::json_value(t), std::bad_alloc&);
+                CHECK_THROWS_AS(my_json::json_value(t), std::bad_alloc);
                 next_construct_fails = false;
             }
         }
@@ -172,7 +172,7 @@ TEST_CASE("controlled bad_alloc")
             my_json::string_t v("foo");
             CHECK_NOTHROW(my_allocator_clean_up(my_json::json_value(v).string));
             next_construct_fails = true;
-            CHECK_THROWS_AS(my_json::json_value(v), std::bad_alloc&);
+            CHECK_THROWS_AS(my_json::json_value(v), std::bad_alloc);
             next_construct_fails = false;
         }
 
@@ -183,7 +183,7 @@ TEST_CASE("controlled bad_alloc")
                     my_json::object_t v {{"foo", "bar"}};
                     CHECK_NOTHROW(my_json::json_value j(v));
                     next_construct_fails = true;
-                    CHECK_THROWS_AS(my_json::json_value j(v), std::bad_alloc&);
+                    CHECK_THROWS_AS(my_json::json_value j(v), std::bad_alloc);
                     next_construct_fails = false;
                 }
         */
@@ -194,7 +194,7 @@ TEST_CASE("controlled bad_alloc")
                     my_json::array_t v = {"foo", "bar", "baz"};
                     CHECK_NOTHROW(my_json::json_value j(v));
                     next_construct_fails = true;
-                    CHECK_THROWS_AS(my_json::json_value j(v), std::bad_alloc&);
+                    CHECK_THROWS_AS(my_json::json_value j(v), std::bad_alloc);
                     next_construct_fails = false;
                 }
         */
@@ -208,7 +208,7 @@ TEST_CASE("controlled bad_alloc")
             std::map<std::string, std::string> v {{"foo", "bar"}};
             CHECK_NOTHROW(my_json(v));
             next_construct_fails = true;
-            CHECK_THROWS_AS(my_json(v), std::bad_alloc&);
+            CHECK_THROWS_AS(my_json(v), std::bad_alloc);
             next_construct_fails = false;
         }
 
@@ -218,7 +218,7 @@ TEST_CASE("controlled bad_alloc")
             std::vector<std::string> v {"foo", "bar", "baz"};
             CHECK_NOTHROW(my_json(v));
             next_construct_fails = true;
-            CHECK_THROWS_AS(my_json(v), std::bad_alloc&);
+            CHECK_THROWS_AS(my_json(v), std::bad_alloc);
             next_construct_fails = false;
         }
 
@@ -227,7 +227,7 @@ TEST_CASE("controlled bad_alloc")
             next_construct_fails = false;
             CHECK_NOTHROW(my_json("foo"));
             next_construct_fails = true;
-            CHECK_THROWS_AS(my_json("foo"), std::bad_alloc&);
+            CHECK_THROWS_AS(my_json("foo"), std::bad_alloc);
             next_construct_fails = false;
         }
 
@@ -237,7 +237,7 @@ TEST_CASE("controlled bad_alloc")
             std::string s("foo");
             CHECK_NOTHROW(my_json(s));
             next_construct_fails = true;
-            CHECK_THROWS_AS(my_json(s), std::bad_alloc&);
+            CHECK_THROWS_AS(my_json(s), std::bad_alloc);
             next_construct_fails = false;
         }
     }

test/src/unit-cbor.cpp

@@ -31,6 +31,7 @@ SOFTWARE.
 #include "json.hpp"
 using nlohmann::json;
 
+#include <set>
 #include <fstream>
 
 TEST_CASE("CBOR")
@@ -739,13 +740,13 @@ TEST_CASE("CBOR")
                 {
                     SECTION("no byte follows")
                     {
-                        CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xf9})), json::parse_error&);
+                        CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xf9})), json::parse_error);
                         CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0xf9})),
                                           "[json.exception.parse_error.110] parse error at 2: unexpected end of input");
                     }
                     SECTION("only one byte follows")
                     {
-                        CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c})), json::parse_error&);
+                        CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c})), json::parse_error);
                         CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0xf9, 0x7c})),
                                           "[json.exception.parse_error.110] parse error at 3: unexpected end of input");
                     }
@@ -1226,28 +1227,28 @@ TEST_CASE("CBOR")
     {
         SECTION("empty byte vector")
         {
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>()), json::parse_error&);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>()), json::parse_error);
             CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>()),
                               "[json.exception.parse_error.110] parse error at 1: unexpected end of input");
         }
 
         SECTION("too short byte vector")
         {
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x18})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x19})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x19, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1a})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1a, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1a, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1a, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x18})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x19})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x19, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1a})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1a, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1a, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1a, 0x00, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error);
 
             CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x18})),
                               "[json.exception.parse_error.110] parse error at 2: unexpected end of input");
@@ -1285,10 +1286,10 @@ TEST_CASE("CBOR")
         {
             SECTION("concrete examples")
             {
-                CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1c})), json::parse_error&);
+                CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0x1c})), json::parse_error);
                 CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0x1c})),
                                   "[json.exception.parse_error.112] parse error at 1: error reading CBOR; last byte: 0x1C");
-                CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xf8})), json::parse_error&);
+                CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xf8})), json::parse_error);
                 CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0xf8})),
                                   "[json.exception.parse_error.112] parse error at 1: error reading CBOR; last byte: 0xF8");
             }
@@ -1339,14 +1340,14 @@ TEST_CASE("CBOR")
                             0xf8
                         })
                 {
-                    CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({static_cast<uint8_t>(byte)})), json::parse_error&);
+                    CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({static_cast<uint8_t>(byte)})), json::parse_error);
                 }
             }
         }
 
         SECTION("invalid string in map")
         {
-            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xa1, 0xff, 0x01})), json::parse_error&);
+            CHECK_THROWS_AS(json::from_cbor(std::vector<uint8_t>({0xa1, 0xff, 0x01})), json::parse_error);
             CHECK_THROWS_WITH(json::from_cbor(std::vector<uint8_t>({0xa1, 0xff, 0x01})),
                               "[json.exception.parse_error.113] parse error at 2: expected a CBOR string; last byte: 0xFF");
         }
@@ -1362,7 +1363,7 @@ TEST_CASE("CBOR")
 
             SECTION("strict mode")
             {
-                CHECK_THROWS_AS(json::from_cbor(vec), json::parse_error&);
+                CHECK_THROWS_AS(json::from_cbor(vec), json::parse_error);
                 CHECK_THROWS_WITH(json::from_cbor(vec),
                                   "[json.exception.parse_error.110] parse error at 2: expected end of input");
             }

test/src/unit-class_const_iterator.cpp

@@ -147,7 +147,7 @@ TEST_CASE("const_iterator class")
             {
                 json j(json::value_t::null);
                 json::const_iterator it = j.cbegin();
-                CHECK_THROWS_AS(*it, json::invalid_iterator&);
+                CHECK_THROWS_AS(*it, json::invalid_iterator);
                 CHECK_THROWS_WITH(*it, "[json.exception.invalid_iterator.214] cannot get value");
             }
 
@@ -157,7 +157,7 @@ TEST_CASE("const_iterator class")
                 json::const_iterator it = j.cbegin();
                 CHECK(*it == json(17));
                 it = j.cend();
-                CHECK_THROWS_AS(*it, json::invalid_iterator&);
+                CHECK_THROWS_AS(*it, json::invalid_iterator);
                 CHECK_THROWS_WITH(*it, "[json.exception.invalid_iterator.214] cannot get value");
             }
 
@@ -182,7 +182,7 @@ TEST_CASE("const_iterator class")
             {
                 json j(json::value_t::null);
                 json::const_iterator it = j.cbegin();
-                CHECK_THROWS_AS(std::string(it->type_name()), json::invalid_iterator&);
+                CHECK_THROWS_AS(std::string(it->type_name()), json::invalid_iterator);
                 CHECK_THROWS_WITH(std::string(it->type_name()), "[json.exception.invalid_iterator.214] cannot get value");
             }
 
@@ -192,7 +192,7 @@ TEST_CASE("const_iterator class")
                 json::const_iterator it = j.cbegin();
                 CHECK(std::string(it->type_name()) == "number");
                 it = j.cend();
-                CHECK_THROWS_AS(std::string(it->type_name()), json::invalid_iterator&);
+                CHECK_THROWS_AS(std::string(it->type_name()), json::invalid_iterator);
                 CHECK_THROWS_WITH(std::string(it->type_name()), "[json.exception.invalid_iterator.214] cannot get value");
             }
 

test/src/unit-class_iterator.cpp

@@ -131,7 +131,7 @@ TEST_CASE("iterator class")
             {
                 json j(json::value_t::null);
                 json::iterator it = j.begin();
-                CHECK_THROWS_AS(*it, json::invalid_iterator&);
+                CHECK_THROWS_AS(*it, json::invalid_iterator);
                 CHECK_THROWS_WITH(*it, "[json.exception.invalid_iterator.214] cannot get value");
             }
 
@@ -141,7 +141,7 @@ TEST_CASE("iterator class")
                 json::iterator it = j.begin();
                 CHECK(*it == json(17));
                 it = j.end();
-                CHECK_THROWS_AS(*it, json::invalid_iterator&);
+                CHECK_THROWS_AS(*it, json::invalid_iterator);
                 CHECK_THROWS_WITH(*it, "[json.exception.invalid_iterator.214] cannot get value");
             }
 
@@ -166,7 +166,7 @@ TEST_CASE("iterator class")
             {
                 json j(json::value_t::null);
                 json::iterator it = j.begin();
-                CHECK_THROWS_AS(std::string(it->type_name()), json::invalid_iterator&);
+                CHECK_THROWS_AS(std::string(it->type_name()), json::invalid_iterator);
                 CHECK_THROWS_WITH(std::string(it->type_name()), "[json.exception.invalid_iterator.214] cannot get value");
             }
 
@@ -176,7 +176,7 @@ TEST_CASE("iterator class")
                 json::iterator it = j.begin();
                 CHECK(std::string(it->type_name()) == "number");
                 it = j.end();
-                CHECK_THROWS_AS(std::string(it->type_name()), json::invalid_iterator&);
+                CHECK_THROWS_AS(std::string(it->type_name()), json::invalid_iterator);
                 CHECK_THROWS_WITH(std::string(it->type_name()), "[json.exception.invalid_iterator.214] cannot get value");
             }
 

test/src/unit-msgpack.cpp

@@ -1016,28 +1016,28 @@ TEST_CASE("MessagePack")
     {
         SECTION("empty byte vector")
         {
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>()), json::parse_error&);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>()), json::parse_error);
             CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>()),
                               "[json.exception.parse_error.110] parse error at 1: unexpected end of input");
         }
 
         SECTION("too short byte vector")
         {
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcc})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcd})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcd, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xce})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xce, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xce, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xce, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error&);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcc})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcd})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcd, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xce})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xce, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xce, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xce, 0x00, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xcf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00})), json::parse_error);
 
             CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xcc})),
                               "[json.exception.parse_error.110] parse error at 2: unexpected end of input");
@@ -1075,10 +1075,10 @@ TEST_CASE("MessagePack")
         {
             SECTION("concrete examples")
             {
-                CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xc1})), json::parse_error&);
+                CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xc1})), json::parse_error);
                 CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xc1})),
                                   "[json.exception.parse_error.112] parse error at 1: error reading MessagePack; last byte: 0xC1");
-                CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xc6})), json::parse_error&);
+                CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0xc6})), json::parse_error);
                 CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0xc6})),
                                   "[json.exception.parse_error.112] parse error at 1: error reading MessagePack; last byte: 0xC6");
             }
@@ -1097,14 +1097,14 @@ TEST_CASE("MessagePack")
                             0xd4, 0xd5, 0xd6, 0xd7, 0xd8
                         })
                 {
-                    CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({static_cast<uint8_t>(byte)})), json::parse_error&);
+                    CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({static_cast<uint8_t>(byte)})), json::parse_error);
                 }
             }
         }
 
         SECTION("invalid string in map")
         {
-            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0x81, 0xff, 0x01})), json::parse_error&);
+            CHECK_THROWS_AS(json::from_msgpack(std::vector<uint8_t>({0x81, 0xff, 0x01})), json::parse_error);
             CHECK_THROWS_WITH(json::from_msgpack(std::vector<uint8_t>({0x81, 0xff, 0x01})),
                               "[json.exception.parse_error.113] parse error at 2: expected a MessagePack string; last byte: 0xFF");
         }
@@ -1120,7 +1120,7 @@ TEST_CASE("MessagePack")
 
             SECTION("strict mode")
             {
-                CHECK_THROWS_AS(json::from_msgpack(vec), json::parse_error&);
+                CHECK_THROWS_AS(json::from_msgpack(vec), json::parse_error);
                 CHECK_THROWS_WITH(json::from_msgpack(vec),
                                   "[json.exception.parse_error.110] parse error at 2: expected end of input");
             }

test/src/unit-readme.cpp

@@ -31,6 +31,7 @@ SOFTWARE.
 #include "json.hpp"
 using nlohmann::json;
 
+#include <set>
 #include <deque>
 #include <forward_list>
 #include <list>

test/src/unit-testsuites.cpp

@@ -78,7 +78,7 @@ TEST_CASE("compliance tests from json.org")
         {
             CAPTURE(filename);
             std::ifstream f(filename);
-            CHECK_THROWS_AS(json::parse(f), json::parse_error&);
+            CHECK_THROWS_AS(json::parse(f), json::parse_error);
         }
     }
 
@@ -772,7 +772,7 @@ TEST_CASE("nst's JSONTestSuite")
             {
                 CAPTURE(filename);
                 std::ifstream f(filename);
-                CHECK_THROWS_AS(json::parse(f), json::parse_error&);
+                CHECK_THROWS_AS(json::parse(f), json::parse_error);
             }
         }
 
@@ -848,7 +848,7 @@ TEST_CASE("nst's JSONTestSuite")
                 CAPTURE(filename);
                 std::ifstream f(filename);
                 json j;
-                CHECK_THROWS_AS(f >> j, json::out_of_range&);
+                CHECK_THROWS_AS(f >> j, json::out_of_range);
             }
         }
 
@@ -875,7 +875,7 @@ TEST_CASE("nst's JSONTestSuite")
                 CAPTURE(filename);
                 std::ifstream f(filename);
                 json j;
-                CHECK_THROWS_AS(f >> j, json::parse_error&);
+                CHECK_THROWS_AS(f >> j, json::parse_error);
             }
         }
     }

test/src/unit-unicode.cpp

@@ -81,7 +81,7 @@ void check_utf8string(bool success_expected, int byte1, int byte2 = -1, int byte
     }
     else
     {
-        CHECK_THROWS_AS(json::parse(json_string), json::parse_error&);
+        CHECK_THROWS_AS(json::parse(json_string), json::parse_error);
     }
 }
 
@@ -928,31 +928,31 @@ TEST_CASE("Unicode", "[hide]")
         {
             SECTION("incorrect surrogate values")
             {
-                CHECK_THROWS_AS(json::parse("\"\\uDC00\\uDC00\""), json::parse_error&);
+                CHECK_THROWS_AS(json::parse("\"\\uDC00\\uDC00\""), json::parse_error);
                 CHECK_THROWS_WITH(json::parse("\"\\uDC00\\uDC00\""),
                                   "[json.exception.parse_error.101] parse error at 7: syntax error - invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF; last read: '\"\\uDC00'");
 
-                CHECK_THROWS_AS(json::parse("\"\\uD7FF\\uDC00\""), json::parse_error&);
+                CHECK_THROWS_AS(json::parse("\"\\uD7FF\\uDC00\""), json::parse_error);
                 CHECK_THROWS_WITH(json::parse("\"\\uD7FF\\uDC00\""),
                                   "[json.exception.parse_error.101] parse error at 13: syntax error - invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF; last read: '\"\\uD7FF\\uDC00'");
 
-                CHECK_THROWS_AS(json::parse("\"\\uD800]\""), json::parse_error&);
+                CHECK_THROWS_AS(json::parse("\"\\uD800]\""), json::parse_error);
                 CHECK_THROWS_WITH(json::parse("\"\\uD800]\""),
                                   "[json.exception.parse_error.101] parse error at 8: syntax error - invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD800]'");
 
-                CHECK_THROWS_AS(json::parse("\"\\uD800\\v\""), json::parse_error&);
+                CHECK_THROWS_AS(json::parse("\"\\uD800\\v\""), json::parse_error);
                 CHECK_THROWS_WITH(json::parse("\"\\uD800\\v\""),
                                   "[json.exception.parse_error.101] parse error at 9: syntax error - invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD800\\v'");
 
-                CHECK_THROWS_AS(json::parse("\"\\uD800\\u123\""), json::parse_error&);
+                CHECK_THROWS_AS(json::parse("\"\\uD800\\u123\""), json::parse_error);
                 CHECK_THROWS_WITH(json::parse("\"\\uD800\\u123\""),
                                   "[json.exception.parse_error.101] parse error at 13: syntax error - invalid string: '\\u' must be followed by 4 hex digits; last read: '\"\\uD800\\u123\"'");
 
-                CHECK_THROWS_AS(json::parse("\"\\uD800\\uDBFF\""), json::parse_error&);
+                CHECK_THROWS_AS(json::parse("\"\\uD800\\uDBFF\""), json::parse_error);
                 CHECK_THROWS_WITH(json::parse("\"\\uD800\\uDBFF\""),
                                   "[json.exception.parse_error.101] parse error at 13: syntax error - invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD800\\uDBFF'");
 
-                CHECK_THROWS_AS(json::parse("\"\\uD800\\uE000\""), json::parse_error&);
+                CHECK_THROWS_AS(json::parse("\"\\uD800\\uE000\""), json::parse_error);
                 CHECK_THROWS_WITH(json::parse("\"\\uD800\\uE000\""),
                                   "[json.exception.parse_error.101] parse error at 13: syntax error - invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF; last read: '\"\\uD800\\uE000'");
             }
@@ -969,7 +969,7 @@ TEST_CASE("Unicode", "[hide]")
                 {
                     std::string json_text = "\"" + codepoint_to_unicode(cp) + "\"";
                     CAPTURE(json_text);
-                    CHECK_THROWS_AS(json::parse(json_text), json::parse_error&);
+                    CHECK_THROWS_AS(json::parse(json_text), json::parse_error);
                 }
             }
 
@@ -988,7 +988,7 @@ TEST_CASE("Unicode", "[hide]")
 
                         std::string json_text = "\"" + codepoint_to_unicode(cp1) + codepoint_to_unicode(cp2) + "\"";
                         CAPTURE(json_text);
-                        CHECK_THROWS_AS(json::parse(json_text), json::parse_error&);
+                        CHECK_THROWS_AS(json::parse(json_text), json::parse_error);
                     }
                 }
             }
@@ -1001,7 +1001,7 @@ TEST_CASE("Unicode", "[hide]")
                 {
                     std::string json_text = "\"" + codepoint_to_unicode(cp) + "\"";
                     CAPTURE(json_text);
-                    CHECK_THROWS_AS(json::parse(json_text), json::parse_error&);
+                    CHECK_THROWS_AS(json::parse(json_text), json::parse_error);
                 }
             }
 
@@ -1072,7 +1072,7 @@ TEST_CASE("Unicode", "[hide]")
 
     SECTION("error for incomplete/wrong BOM")
     {
-        CHECK_THROWS_AS(json::parse("\xef\xbb"), json::parse_error&);
-        CHECK_THROWS_AS(json::parse("\xef\xbb\xbb"), json::parse_error&);
+        CHECK_THROWS_AS(json::parse("\xef\xbb"), json::parse_error);
+        CHECK_THROWS_AS(json::parse("\xef\xbb\xbb"), json::parse_error);
     }
 }