Skip to content

Commit 4353619

Browse files
jpetsojpetso
authored
Merge pull request #50 from jpetso/extra_warnings
Last bunch of warning-related fixes for now
2 parents a4cf344 + be82262 commit 4353619

File tree

2 files changed

+67
-67
lines changed

2 files changed

+67
-67
lines changed

‎cppcodec/detail/stream_codec.hpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -241,7 +241,7 @@ struct alphabet_index_info
241241
static constexpr const alphabet_index_t padding_idx = 1 << 8;
242242
static constexpr const alphabet_index_t invalid_idx = 1 << 9;
243243
static constexpr const alphabet_index_t eof_idx = 1 << 10;
244-
static constexpr const alphabet_index_t stop_character_mask = 0xFF00;
244+
static constexpr const alphabet_index_t stop_character_mask{~0xFFu};
245245

246246
static constexpr const bool padding_allowed = padding_searcher<
247247
CodecVariant, num_possible_symbols>::exists_padding_symbol();

‎test/test_cppcodec.cpp‎

Lines changed: 66 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -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"), 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);
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&);
132132

133133
// An invalid symbol should throw a symbol error.
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
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
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"), 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);
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&);
333333

334334
// An invalid symbol should throw a symbol error.
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
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
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"), 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);
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&);
440440

441441
// An invalid symbol should throw a symbol error.
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
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
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"), 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);
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&);
580580

581581
// An invalid symbol should throw a symbol error.
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
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
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="), cppcodec::padding_error);
677+
REQUIRE_THROWS_AS(base64::decode<std::string>("Zg="), const 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"), cppcodec::invalid_input_length);
686-
REQUIRE_THROWS_AS(base64::decode("AAAAA"), cppcodec::invalid_input_length);
685+
REQUIRE_THROWS_AS(base64::decode("A"), const cppcodec::invalid_input_length&);
686+
REQUIRE_THROWS_AS(base64::decode("AAAAA"), const cppcodec::invalid_input_length&);
687687

688688
// An invalid symbol should throw a symbol error.
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
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
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"), 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);
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&);
791791

792792
// An invalid symbol should throw a symbol error.
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
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
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"), cppcodec::invalid_input_length);
887-
REQUIRE_THROWS_AS(hex::decode("000"), cppcodec::invalid_input_length);
886+
REQUIRE_THROWS_AS(hex::decode("0"), const cppcodec::invalid_input_length&);
887+
REQUIRE_THROWS_AS(hex::decode("000"), const cppcodec::invalid_input_length&);
888888

889889
// An invalid symbol should throw a symbol error.
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
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
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"), cppcodec::invalid_input_length);
984-
REQUIRE_THROWS_AS(hex::decode("000"), cppcodec::invalid_input_length);
983+
REQUIRE_THROWS_AS(hex::decode("0"), const cppcodec::invalid_input_length&);
984+
REQUIRE_THROWS_AS(hex::decode("000"), const cppcodec::invalid_input_length&);
985985

986986
// An invalid symbol should throw a symbol error.
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
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
990990
}
991991
}

0 commit comments

Comments
 (0)