Skip to content

Commit 302dc28

Browse files
jpetsojpetso
authored
Merge pull request #55 from jpetso/master
Update Catch to v2.3.0.
2 parents 661f149 + b9e3bba commit 302dc28

File tree

3 files changed

+69
-69
lines changed

3 files changed

+69
-69
lines changed

‎test/CMakeLists.txt‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@ include_directories(BEFORE ${PROJECT_SOURCE_DIR})
33

44
find_package(PkgConfig)
55
if (PKG_CONFIG_FOUND)
6-
pkg_check_modules(CATCH2 catch)
6+
pkg_check_modules(CATCH2 catch2)
77
endif()
88

99
if (CATCH2_FOUND)

‎test/catch‎

Submodule catch updated 395 files

‎test/test_cppcodec.cpp‎

Lines changed: 67 additions & 67 deletions
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,7 @@
2222
*/
2323

2424
#define CATCH_CONFIG_MAIN
25-
#include <catch.hpp>
25+
#include <catch2/catch.hpp>
2626

2727
#include <cppcodec/base32_crockford.hpp>
2828
#include <cppcodec/base32_hex.hpp>
@@ -125,16 +125,16 @@ TEST_CASE("Douglas Crockford's base32", "[base32][crockford]") {
125125
REQUIRE(base32::decode<std::string>("-C-SQ--PY-") == "foo");
126126

127127
// An invalid number of symbols should throw the right kind of parse_error.
128-
REQUIRE_THROWS_AS(base32::decode("0"), const cppcodec::invalid_input_length&);
129-
REQUIRE_THROWS_AS(base32::decode("000"), const cppcodec::invalid_input_length&);
130-
REQUIRE_THROWS_AS(base32::decode("000000"), const cppcodec::invalid_input_length&);
131-
REQUIRE_THROWS_AS(base32::decode("000000000"), const cppcodec::invalid_input_length&);
128+
REQUIRE_THROWS_AS(base32::decode("0"), cppcodec::invalid_input_length);
129+
REQUIRE_THROWS_AS(base32::decode("000"), cppcodec::invalid_input_length);
130+
REQUIRE_THROWS_AS(base32::decode("000000"), cppcodec::invalid_input_length);
131+
REQUIRE_THROWS_AS(base32::decode("000000000"), cppcodec::invalid_input_length);
132132

133133
// An invalid symbol should throw a symbol error.
134-
REQUIRE_THROWS_AS(base32::decode("00======"), const cppcodec::symbol_error&); // no padding for Crockford
135-
REQUIRE_THROWS_AS(base32::decode("Uu"), const cppcodec::symbol_error&); // only a checksum symbol here
136-
REQUIRE_THROWS_AS(base32::decode("++"), const cppcodec::symbol_error&); // make sure it's not base64
137-
REQUIRE_THROWS_AS(base32::decode("//"), const cppcodec::symbol_error&); // ...ditto
134+
REQUIRE_THROWS_AS(base32::decode("00======"), cppcodec::symbol_error); // no padding for Crockford
135+
REQUIRE_THROWS_AS(base32::decode("Uu"), cppcodec::symbol_error); // only a checksum symbol here
136+
REQUIRE_THROWS_AS(base32::decode("++"), cppcodec::symbol_error); // make sure it's not base64
137+
REQUIRE_THROWS_AS(base32::decode("//"), cppcodec::symbol_error); // ...ditto
138138
}
139139

140140
// Only test overloads once (for base32_crockford, since it happens to be the first one).
@@ -324,20 +324,20 @@ TEST_CASE("base32hex", "[base32][hex]") {
324324
REQUIRE(base32::decode<std::string>("cPnMuOj1") == "fooba");
325325

326326
// An invalid number of symbols should throw the right kind of parse_error.
327-
REQUIRE_THROWS_AS(base32::decode("0"), const cppcodec::padding_error&);
328-
REQUIRE_THROWS_AS(base32::decode("00"), const cppcodec::padding_error&);
329-
REQUIRE_THROWS_AS(base32::decode("00==="), const cppcodec::padding_error&);
330-
REQUIRE_THROWS_AS(base32::decode("0======="), const cppcodec::invalid_input_length&);
331-
REQUIRE_THROWS_AS(base32::decode("000====="), const cppcodec::invalid_input_length&);
332-
REQUIRE_THROWS_AS(base32::decode("000000=="), const cppcodec::invalid_input_length&);
327+
REQUIRE_THROWS_AS(base32::decode("0"), cppcodec::padding_error);
328+
REQUIRE_THROWS_AS(base32::decode("00"), cppcodec::padding_error);
329+
REQUIRE_THROWS_AS(base32::decode("00==="), cppcodec::padding_error);
330+
REQUIRE_THROWS_AS(base32::decode("0======="), cppcodec::invalid_input_length);
331+
REQUIRE_THROWS_AS(base32::decode("000====="), cppcodec::invalid_input_length);
332+
REQUIRE_THROWS_AS(base32::decode("000000=="), cppcodec::invalid_input_length);
333333

334334
// An invalid symbol should throw a symbol error.
335-
REQUIRE_THROWS_AS(base32::decode("W0======"), const cppcodec::symbol_error&);
336-
REQUIRE_THROWS_AS(base32::decode("X0======"), const cppcodec::symbol_error&);
337-
REQUIRE_THROWS_AS(base32::decode("Y0======"), const cppcodec::symbol_error&);
338-
REQUIRE_THROWS_AS(base32::decode("Z0======"), const cppcodec::symbol_error&);
339-
REQUIRE_THROWS_AS(base32::decode("CPNM UOJ1"), const cppcodec::symbol_error&); // no spaces
340-
REQUIRE_THROWS_AS(base32::decode("CPNM-UOJ1"), const cppcodec::symbol_error&); // no dashes
335+
REQUIRE_THROWS_AS(base32::decode("W0======"), cppcodec::symbol_error);
336+
REQUIRE_THROWS_AS(base32::decode("X0======"), cppcodec::symbol_error);
337+
REQUIRE_THROWS_AS(base32::decode("Y0======"), cppcodec::symbol_error);
338+
REQUIRE_THROWS_AS(base32::decode("Z0======"), cppcodec::symbol_error);
339+
REQUIRE_THROWS_AS(base32::decode("CPNM UOJ1"), cppcodec::symbol_error); // no spaces
340+
REQUIRE_THROWS_AS(base32::decode("CPNM-UOJ1"), cppcodec::symbol_error); // no dashes
341341
}
342342
}
343343

@@ -431,20 +431,20 @@ TEST_CASE("base32 (RFC 4648)", "[base32][rfc4648]") {
431431
REQUIRE(base32::decode<std::string>("mZxW6yTb") == "fooba");
432432

433433
// An invalid number of symbols should throw the right kind of parse_error.
434-
REQUIRE_THROWS_AS(base32::decode("A"), const cppcodec::padding_error&);
435-
REQUIRE_THROWS_AS(base32::decode("AA"), const cppcodec::padding_error&);
436-
REQUIRE_THROWS_AS(base32::decode("AA==="), const cppcodec::padding_error&);
437-
REQUIRE_THROWS_AS(base32::decode("A======="), const cppcodec::invalid_input_length&);
438-
REQUIRE_THROWS_AS(base32::decode("AAA====="), const cppcodec::invalid_input_length&);
439-
REQUIRE_THROWS_AS(base32::decode("AAAAAA=="), const cppcodec::invalid_input_length&);
434+
REQUIRE_THROWS_AS(base32::decode("A"), cppcodec::padding_error);
435+
REQUIRE_THROWS_AS(base32::decode("AA"), cppcodec::padding_error);
436+
REQUIRE_THROWS_AS(base32::decode("AA==="), cppcodec::padding_error);
437+
REQUIRE_THROWS_AS(base32::decode("A======="), cppcodec::invalid_input_length);
438+
REQUIRE_THROWS_AS(base32::decode("AAA====="), cppcodec::invalid_input_length);
439+
REQUIRE_THROWS_AS(base32::decode("AAAAAA=="), cppcodec::invalid_input_length);
440440

441441
// An invalid symbol should throw a symbol error.
442-
REQUIRE_THROWS_AS(base32::decode("0A======"), const cppcodec::symbol_error&);
443-
REQUIRE_THROWS_AS(base32::decode("1A======"), const cppcodec::symbol_error&);
444-
REQUIRE_THROWS_AS(base32::decode("8A======"), const cppcodec::symbol_error&);
445-
REQUIRE_THROWS_AS(base32::decode("9A======"), const cppcodec::symbol_error&);
446-
REQUIRE_THROWS_AS(base32::decode("GEZD GNBV"), const cppcodec::symbol_error&); // no spaces
447-
REQUIRE_THROWS_AS(base32::decode("GEZD-GNBV"), const cppcodec::symbol_error&); // no dashes
442+
REQUIRE_THROWS_AS(base32::decode("0A======"), cppcodec::symbol_error);
443+
REQUIRE_THROWS_AS(base32::decode("1A======"), cppcodec::symbol_error);
444+
REQUIRE_THROWS_AS(base32::decode("8A======"), cppcodec::symbol_error);
445+
REQUIRE_THROWS_AS(base32::decode("9A======"), cppcodec::symbol_error);
446+
REQUIRE_THROWS_AS(base32::decode("GEZD GNBV"), cppcodec::symbol_error); // no spaces
447+
REQUIRE_THROWS_AS(base32::decode("GEZD-GNBV"), cppcodec::symbol_error); // no dashes
448448
}
449449
}
450450

@@ -571,17 +571,17 @@ TEST_CASE("base64 (RFC 4648)", "[base64][rfc4648]") {
571571
REQUIRE(base64::decode("////") == std::vector<uint8_t>({255, 255, 255}));
572572

573573
// An invalid number of symbols should throw the right kind of parse_error.
574-
REQUIRE_THROWS_AS(base64::decode("A"), const cppcodec::padding_error&);
575-
REQUIRE_THROWS_AS(base64::decode("AA"), const cppcodec::padding_error&);
576-
REQUIRE_THROWS_AS(base64::decode("ABCDE"), const cppcodec::padding_error&);
577-
REQUIRE_THROWS_AS(base64::decode("A==="), const cppcodec::invalid_input_length&);
578-
REQUIRE_THROWS_AS(base64::decode("AAAA===="), const cppcodec::invalid_input_length&);
579-
REQUIRE_THROWS_AS(base64::decode("AAAAA==="), const cppcodec::invalid_input_length&);
574+
REQUIRE_THROWS_AS(base64::decode("A"), cppcodec::padding_error);
575+
REQUIRE_THROWS_AS(base64::decode("AA"), cppcodec::padding_error);
576+
REQUIRE_THROWS_AS(base64::decode("ABCDE"), cppcodec::padding_error);
577+
REQUIRE_THROWS_AS(base64::decode("A==="), cppcodec::invalid_input_length);
578+
REQUIRE_THROWS_AS(base64::decode("AAAA===="), cppcodec::invalid_input_length);
579+
REQUIRE_THROWS_AS(base64::decode("AAAAA==="), cppcodec::invalid_input_length);
580580

581581
// An invalid symbol should throw a symbol error.
582-
REQUIRE_THROWS_AS(base64::decode("A&B="), const cppcodec::symbol_error&);
583-
REQUIRE_THROWS_AS(base64::decode("--"), const cppcodec::symbol_error&); // this is not base64url
584-
REQUIRE_THROWS_AS(base64::decode("__"), const cppcodec::symbol_error&); // ...ditto
582+
REQUIRE_THROWS_AS(base64::decode("A&B="), cppcodec::symbol_error);
583+
REQUIRE_THROWS_AS(base64::decode("--"), cppcodec::symbol_error); // this is not base64url
584+
REQUIRE_THROWS_AS(base64::decode("__"), cppcodec::symbol_error); // ...ditto
585585
}
586586
}
587587

@@ -674,21 +674,21 @@ TEST_CASE("base64 (unpadded URL-safe)", "[base64][url_unpadded]") {
674674
REQUIRE(base64::decode<std::string>("Zm9vYmFy") == "foobar");
675675

676676
// Unpadded base64_url allows padding, but an incorrect number of padding characters is still wrong.
677-
REQUIRE_THROWS_AS(base64::decode<std::string>("Zg="), const cppcodec::padding_error&);
677+
REQUIRE_THROWS_AS(base64::decode<std::string>("Zg="), cppcodec::padding_error);
678678

679679
// Other test strings.
680680
REQUIRE(base64::decode<std::string>("MTIz") == "123");
681681
REQUIRE(base64::decode<std::string>("QUJD") == "ABC");
682682
REQUIRE(base64::decode("____") == std::vector<uint8_t>({255, 255, 255}));
683683

684684
// An invalid number of symbols should throw the right kind of parse_error.
685-
REQUIRE_THROWS_AS(base64::decode("A"), const cppcodec::invalid_input_length&);
686-
REQUIRE_THROWS_AS(base64::decode("AAAAA"), const cppcodec::invalid_input_length&);
685+
REQUIRE_THROWS_AS(base64::decode("A"), cppcodec::invalid_input_length);
686+
REQUIRE_THROWS_AS(base64::decode("AAAAA"), cppcodec::invalid_input_length);
687687

688688
// An invalid symbol should throw a symbol error.
689-
REQUIRE_THROWS_AS(base64::decode("A&B"), const cppcodec::symbol_error&);
690-
REQUIRE_THROWS_AS(base64::decode("++"), const cppcodec::symbol_error&); // this is not standard base64
691-
REQUIRE_THROWS_AS(base64::decode("//"), const cppcodec::symbol_error&); // ...ditto
689+
REQUIRE_THROWS_AS(base64::decode("A&B"), cppcodec::symbol_error);
690+
REQUIRE_THROWS_AS(base64::decode("++"), cppcodec::symbol_error); // this is not standard base64
691+
REQUIRE_THROWS_AS(base64::decode("//"), cppcodec::symbol_error); // ...ditto
692692
}
693693
}
694694

@@ -782,17 +782,17 @@ TEST_CASE("base64 (URL-safe)", "[base64][url]") {
782782
REQUIRE(base64::decode("____") == std::vector<uint8_t>({255, 255, 255}));
783783

784784
// An invalid number of symbols should throw the right kind of parse_error.
785-
REQUIRE_THROWS_AS(base64::decode("A"), const cppcodec::padding_error&);
786-
REQUIRE_THROWS_AS(base64::decode("AA"), const cppcodec::padding_error&);
787-
REQUIRE_THROWS_AS(base64::decode("ABCDE"), const cppcodec::padding_error&);
788-
REQUIRE_THROWS_AS(base64::decode("A==="), const cppcodec::invalid_input_length&);
789-
REQUIRE_THROWS_AS(base64::decode("AAAA===="), const cppcodec::invalid_input_length&);
790-
REQUIRE_THROWS_AS(base64::decode("AAAAA==="), const cppcodec::invalid_input_length&);
785+
REQUIRE_THROWS_AS(base64::decode("A"), cppcodec::padding_error);
786+
REQUIRE_THROWS_AS(base64::decode("AA"), cppcodec::padding_error);
787+
REQUIRE_THROWS_AS(base64::decode("ABCDE"), cppcodec::padding_error);
788+
REQUIRE_THROWS_AS(base64::decode("A==="), cppcodec::invalid_input_length);
789+
REQUIRE_THROWS_AS(base64::decode("AAAA===="), cppcodec::invalid_input_length);
790+
REQUIRE_THROWS_AS(base64::decode("AAAAA==="), cppcodec::invalid_input_length);
791791

792792
// An invalid symbol should throw a symbol error.
793-
REQUIRE_THROWS_AS(base64::decode("A&B="), const cppcodec::symbol_error&);
794-
REQUIRE_THROWS_AS(base64::decode("++"), const cppcodec::symbol_error&); // this is not standard base64
795-
REQUIRE_THROWS_AS(base64::decode("//"), const cppcodec::symbol_error&); // ...ditto
793+
REQUIRE_THROWS_AS(base64::decode("A&B="), cppcodec::symbol_error);
794+
REQUIRE_THROWS_AS(base64::decode("++"), cppcodec::symbol_error); // this is not standard base64
795+
REQUIRE_THROWS_AS(base64::decode("//"), cppcodec::symbol_error); // ...ditto
796796
}
797797
}
798798

@@ -883,13 +883,13 @@ TEST_CASE("hex (lowercase)", "[hex][lower]") {
883883
REQUIRE(hex::decode<std::string>("666F6f6261") == "fooba");
884884

885885
// An invalid number of symbols should throw the right kind of parse_error.
886-
REQUIRE_THROWS_AS(hex::decode("0"), const cppcodec::invalid_input_length&);
887-
REQUIRE_THROWS_AS(hex::decode("000"), const cppcodec::invalid_input_length&);
886+
REQUIRE_THROWS_AS(hex::decode("0"), cppcodec::invalid_input_length);
887+
REQUIRE_THROWS_AS(hex::decode("000"), cppcodec::invalid_input_length);
888888

889889
// An invalid symbol should throw a symbol error.
890-
REQUIRE_THROWS_AS(hex::decode("1g"), const cppcodec::symbol_error&);
891-
REQUIRE_THROWS_AS(hex::decode("66 6f"), const cppcodec::symbol_error&); // no spaces
892-
REQUIRE_THROWS_AS(hex::decode("66-6f"), const cppcodec::symbol_error&); // no dashes
890+
REQUIRE_THROWS_AS(hex::decode("1g"), cppcodec::symbol_error);
891+
REQUIRE_THROWS_AS(hex::decode("66 6f"), cppcodec::symbol_error); // no spaces
892+
REQUIRE_THROWS_AS(hex::decode("66-6f"), cppcodec::symbol_error); // no dashes
893893
}
894894
}
895895

@@ -980,12 +980,12 @@ TEST_CASE("hex (uppercase)", "[hex][upper]") {
980980
REQUIRE(hex::decode<std::string>("666f6F6261") == "fooba");
981981

982982
// An invalid number of symbols should throw the right kind of parse_error.
983-
REQUIRE_THROWS_AS(hex::decode("0"), const cppcodec::invalid_input_length&);
984-
REQUIRE_THROWS_AS(hex::decode("000"), const cppcodec::invalid_input_length&);
983+
REQUIRE_THROWS_AS(hex::decode("0"), cppcodec::invalid_input_length);
984+
REQUIRE_THROWS_AS(hex::decode("000"), cppcodec::invalid_input_length);
985985

986986
// An invalid symbol should throw a symbol error.
987-
REQUIRE_THROWS_AS(hex::decode("1G"), const cppcodec::symbol_error&);
988-
REQUIRE_THROWS_AS(hex::decode("66 6F"), const cppcodec::symbol_error&); // no spaces
989-
REQUIRE_THROWS_AS(hex::decode("66-6F"), const cppcodec::symbol_error&); // no dashes
987+
REQUIRE_THROWS_AS(hex::decode("1G"), cppcodec::symbol_error);
988+
REQUIRE_THROWS_AS(hex::decode("66 6F"), cppcodec::symbol_error); // no spaces
989+
REQUIRE_THROWS_AS(hex::decode("66-6F"), cppcodec::symbol_error); // no dashes
990990
}
991991
}

0 commit comments

Comments
 (0)