Skip to content
This repository was archived by the owner on Jun 15, 2025. It is now read-only.

Commit b2cd7e5

Browse files
dermojodermojo
committed
silencing compiler warnings from GCC 7
1 parent 967b88d commit b2cd7e5

File tree

3 files changed

+123
-74
lines changed

3 files changed

+123
-74
lines changed

‎include/spsl/hash.hpp‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -167,10 +167,10 @@ inline void MurmurHash3_x86_32(const uint8_t* data, const uint32_t len, uint32_t
167167
{
168168
case 3:
169169
k1 ^= static_cast<uint32_t>(tail[2] << 16);
170-
/* no break */
170+
/* fallthrough */
171171
case 2:
172172
k1 ^= static_cast<uint32_t>(tail[1] << 8);
173-
/* no break */
173+
/* fallthrough */
174174
case 1:
175175
k1 ^= tail[0];
176176
k1 *= c1;
@@ -241,51 +241,51 @@ inline void MurmurHash3_x64_128(const uint8_t* data, const std::size_t len, cons
241241
{
242242
case 15:
243243
k2 ^= (static_cast<uint64_t>(tail[14])) << 48;
244-
/* no break */
244+
/* fallthrough */
245245
case 14:
246246
k2 ^= (static_cast<uint64_t>(tail[13])) << 40;
247-
/* no break */
247+
/* fallthrough */
248248
case 13:
249249
k2 ^= (static_cast<uint64_t>(tail[12])) << 32;
250-
/* no break */
250+
/* fallthrough */
251251
case 12:
252252
k2 ^= (static_cast<uint64_t>(tail[11])) << 24;
253-
/* no break */
253+
/* fallthrough */
254254
case 11:
255255
k2 ^= (static_cast<uint64_t>(tail[10])) << 16;
256-
/* no break */
256+
/* fallthrough */
257257
case 10:
258258
k2 ^= (static_cast<uint64_t>(tail[9])) << 8;
259-
/* no break */
259+
/* fallthrough */
260260
case 9:
261261
k2 ^= (static_cast<uint64_t>(tail[8])) << 0;
262262
k2 *= c2;
263263
k2 = SPSL_ROTL64(k2, 33);
264264
k2 *= c1;
265265
h2 ^= k2;
266-
/* no break */
266+
/* fallthrough */
267267

268268
case 8:
269269
k1 ^= (static_cast<uint64_t>(tail[7])) << 56;
270-
/* no break */
270+
/* fallthrough */
271271
case 7:
272272
k1 ^= (static_cast<uint64_t>(tail[6])) << 48;
273-
/* no break */
273+
/* fallthrough */
274274
case 6:
275275
k1 ^= (static_cast<uint64_t>(tail[5])) << 40;
276-
/* no break */
276+
/* fallthrough */
277277
case 5:
278278
k1 ^= (static_cast<uint64_t>(tail[4])) << 32;
279-
/* no break */
279+
/* fallthrough */
280280
case 4:
281281
k1 ^= (static_cast<uint64_t>(tail[3])) << 24;
282-
/* no break */
282+
/* fallthrough */
283283
case 3:
284284
k1 ^= (static_cast<uint64_t>(tail[2])) << 16;
285-
/* no break */
285+
/* fallthrough */
286286
case 2:
287287
k1 ^= (static_cast<uint64_t>(tail[1])) << 8;
288-
/* no break */
288+
/* fallthrough */
289289
case 1:
290290
k1 ^= (static_cast<uint64_t>(tail[0])) << 0;
291291
k1 *= c1;

‎test/test_stringcore.cpp‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -927,9 +927,13 @@ TYPED_TEST(StringCoreTest, ComparisonFunctions)
927927
ASSERT_EQ(s.compare(0, s.size(), ref.c_str()), 0);
928928
ASSERT_LT(s.compare(0, s.size() - 1, ref.c_str()), 0);
929929
if (s[0] > s[1])
930+
{
930931
ASSERT_LT(s.compare(1, s.size(), ref.c_str()), 0);
932+
}
931933
else if (s[0] < s[1])
934+
{
932935
ASSERT_GT(s.compare(1, s.size(), ref.c_str()), 0);
936+
}
933937
ASSERT_EQ(s.compare(1, s.size() - 1, ref.c_str() + 1), 0);
934938
ref.pop_back();
935939
ASSERT_GT(s.compare(0, s.size(), ref.c_str()), 0);
@@ -942,9 +946,13 @@ TYPED_TEST(StringCoreTest, ComparisonFunctions)
942946
ASSERT_GT(s.compare(0, s.size() - 2, ref.c_str(), ref.size() - 3), 0);
943947
ASSERT_LT(s.compare(0, s.size() - 1, ref.c_str(), ref.size()), 0);
944948
if (s[0] > s[1])
949+
{
945950
ASSERT_LT(s.compare(1, s.size(), ref.c_str(), ref.size()), 0);
951+
}
946952
else if (s[0] < s[1])
953+
{
947954
ASSERT_GT(s.compare(1, s.size(), ref.c_str(), ref.size()), 0);
955+
}
948956
ASSERT_EQ(s.compare(1, s.size() - 1, ref.c_str() + 1, ref.size() - 1), 0);
949957
ref.pop_back();
950958
ASSERT_GT(s.compare(0, s.size(), ref.c_str(), ref.size()), 0);
@@ -968,9 +976,13 @@ TYPED_TEST(StringCoreTest, ComparisonFunctions)
968976
ASSERT_EQ(s.compare(0, s.size(), ref), 0);
969977
ASSERT_LT(s.compare(0, s.size() - 1, ref), 0);
970978
if (s[0] > s[1])
979+
{
971980
ASSERT_LT(s.compare(1, s.size(), ref), 0);
981+
}
972982
else if (s[0] < s[1])
983+
{
973984
ASSERT_GT(s.compare(1, s.size(), ref), 0);
985+
}
974986
auto ref2 = ref.substr(1);
975987
ASSERT_EQ(s.compare(1, s.size() - 1, ref2), 0);
976988
ref.pop_back();

‎test/test_traits.cpp‎

Lines changed: 95 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -16,89 +16,126 @@ class TypeTraitsTest : public ::testing::Test
1616
{
1717
};
1818

19+
// Note: wrapper macros to ensure that GTest gets actual variables (required in order to print them)
20+
21+
#define ASSERT_HAS_SIZE(S, T) \
22+
{ \
23+
const bool hasSize = spsl::has_size<S, T>::value; \
24+
ASSERT_TRUE(hasSize); \
25+
}
26+
27+
#define ASSERT_HAS_NO_SIZE(S, T) \
28+
{ \
29+
const bool hasSize = spsl::has_size<S, T>::value; \
30+
ASSERT_FALSE(hasSize); \
31+
}
32+
33+
#define ASSERT_HAS_DATA(S, T) \
34+
{ \
35+
const bool hasData = spsl::has_data<S, T>::value; \
36+
ASSERT_TRUE(hasData); \
37+
}
38+
39+
#define ASSERT_HAS_NO_DATA(S, T) \
40+
{ \
41+
const bool hasData = spsl::has_data<S, T>::value; \
42+
ASSERT_FALSE(hasData); \
43+
}
44+
45+
#define ASSERT_IS_COMPAT(C, S, T) \
46+
{ \
47+
const bool isCompat = spsl::is_compatible_string<C, S, T>::value; \
48+
ASSERT_TRUE(isCompat); \
49+
}
50+
51+
#define ASSERT_IS_NOT_COMPAT(C, S, T) \
52+
{ \
53+
const bool isCompat = spsl::is_compatible_string<C, S, T>::value; \
54+
ASSERT_FALSE(isCompat); \
55+
}
56+
1957
// test the has_size traits template
2058
TEST(TypeTraitsTest, HasSize)
2159
{
22-
ASSERT_TRUE((spsl::has_size<size_t, std::string>::value));
23-
ASSERT_TRUE((spsl::has_size<size_t, std::wstring>::value));
60+
ASSERT_HAS_SIZE(size_t, std::string);
61+
ASSERT_HAS_SIZE(size_t, std::wstring);
2462

25-
ASSERT_TRUE((spsl::has_size<size_t, std::vector<char>>::value));
26-
ASSERT_TRUE((spsl::has_size<size_t, std::vector<wchar_t>>::value));
63+
ASSERT_HAS_SIZE(size_t, std::vector<char>);
64+
ASSERT_HAS_SIZE(size_t, std::vector<wchar_t>);
2765

28-
ASSERT_TRUE((spsl::has_size<size_t, spsl::ArrayString<32>>::value));
29-
ASSERT_TRUE((spsl::has_size<size_t, spsl::ArrayStringW<32>>::value));
30-
ASSERT_TRUE((spsl::has_size<size_t, spsl::PasswordString>::value));
31-
ASSERT_TRUE((spsl::has_size<size_t, spsl::PasswordStringW>::value));
66+
ASSERT_HAS_SIZE(size_t, spsl::ArrayString<32>);
67+
ASSERT_HAS_SIZE(size_t, spsl::ArrayStringW<32>);
68+
ASSERT_HAS_SIZE(size_t, spsl::PasswordString);
69+
ASSERT_HAS_SIZE(size_t, spsl::PasswordStringW);
3270

3371
#ifdef TEST_STRING_VIEW
34-
ASSERT_TRUE((spsl::has_size<size_t, std::experimental::string_view>::value));
35-
ASSERT_TRUE((spsl::has_size<size_t, std::experimental::wstring_view>::value));
72+
ASSERT_HAS_SIZE(size_t, std::experimental::string_view);
73+
ASSERT_HAS_SIZE(size_t, std::experimental::wstring_view);
3674
#endif
3775

38-
ASSERT_FALSE((spsl::has_size<size_t, const char*>::value));
39-
ASSERT_FALSE((spsl::has_size<size_t, std::exception>::value));
76+
ASSERT_HAS_NO_SIZE(size_t, const char*);
77+
ASSERT_HAS_NO_SIZE(size_t, std::exception);
4078
}
4179

4280
// test the has_data traits template
4381
TEST(TypeTraitsTest, HasData)
4482
{
45-
ASSERT_TRUE((spsl::has_data<char, std::string>::value));
46-
ASSERT_TRUE((spsl::has_data<wchar_t, std::wstring>::value));
47-
ASSERT_FALSE((spsl::has_data<wchar_t, std::string>::value));
48-
ASSERT_FALSE((spsl::has_data<char, std::wstring>::value));
49-
50-
ASSERT_TRUE((spsl::has_data<char, std::vector<char>>::value));
51-
ASSERT_TRUE((spsl::has_data<wchar_t, std::vector<wchar_t>>::value));
52-
ASSERT_FALSE((spsl::has_data<wchar_t, std::vector<char>>::value));
53-
ASSERT_FALSE((spsl::has_data<char, std::vector<wchar_t>>::value));
54-
55-
ASSERT_TRUE((spsl::has_data<char, spsl::ArrayString<32>>::value));
56-
ASSERT_TRUE((spsl::has_data<wchar_t, spsl::ArrayStringW<32>>::value));
57-
ASSERT_TRUE((spsl::has_data<char, spsl::PasswordString>::value));
58-
ASSERT_TRUE((spsl::has_data<wchar_t, spsl::PasswordStringW>::value));
59-
ASSERT_FALSE((spsl::has_data<wchar_t, spsl::ArrayString<32>>::value));
60-
ASSERT_FALSE((spsl::has_data<char, spsl::ArrayStringW<32>>::value));
61-
ASSERT_FALSE((spsl::has_data<wchar_t, spsl::PasswordString>::value));
62-
ASSERT_FALSE((spsl::has_data<char, spsl::PasswordStringW>::value));
83+
ASSERT_HAS_DATA(char, std::string);
84+
ASSERT_HAS_DATA(wchar_t, std::wstring);
85+
ASSERT_HAS_NO_DATA(wchar_t, std::string);
86+
ASSERT_HAS_NO_DATA(char, std::wstring);
87+
88+
ASSERT_HAS_DATA(char, std::vector<char>);
89+
ASSERT_HAS_DATA(wchar_t, std::vector<wchar_t>);
90+
ASSERT_HAS_NO_DATA(wchar_t, std::vector<char>);
91+
ASSERT_HAS_NO_DATA(char, std::vector<wchar_t>);
92+
93+
ASSERT_HAS_DATA(char, spsl::ArrayString<32>);
94+
ASSERT_HAS_DATA(wchar_t, spsl::ArrayStringW<32>);
95+
ASSERT_HAS_DATA(char, spsl::PasswordString);
96+
ASSERT_HAS_DATA(wchar_t, spsl::PasswordStringW);
97+
ASSERT_HAS_NO_DATA(wchar_t, spsl::ArrayString<32>);
98+
ASSERT_HAS_NO_DATA(char, spsl::ArrayStringW<32>);
99+
ASSERT_HAS_NO_DATA(wchar_t, spsl::PasswordString);
100+
ASSERT_HAS_NO_DATA(char, spsl::PasswordStringW);
63101

64102
#ifdef TEST_STRING_VIEW
65-
ASSERT_TRUE((spsl::has_data<char, std::experimental::string_view>::value));
66-
ASSERT_TRUE((spsl::has_data<wchar_t, std::experimental::wstring_view>::value));
103+
ASSERT_HAS_DATA(char, std::experimental::string_view);
104+
ASSERT_HAS_DATA(wchar_t, std::experimental::wstring_view);
67105
#endif
68106

69-
ASSERT_FALSE((spsl::has_data<char, const char*>::value));
70-
ASSERT_FALSE((spsl::has_data<char, std::exception>::value));
107+
ASSERT_HAS_NO_DATA(char, const char*);
108+
ASSERT_HAS_NO_DATA(char, std::exception);
71109
}
72110

73111
// test the is_compatible_string traits template
74112
TEST(TypeTraitsTest, IsCompatible)
75113
{
76-
ASSERT_TRUE((spsl::is_compatible_string<char, size_t, std::string>::value));
77-
ASSERT_TRUE((spsl::is_compatible_string<wchar_t, size_t, std::wstring>::value));
78-
ASSERT_FALSE((spsl::is_compatible_string<wchar_t, size_t, std::string>::value));
79-
ASSERT_FALSE((spsl::is_compatible_string<char, size_t, std::wstring>::value));
80-
81-
ASSERT_TRUE((spsl::is_compatible_string<char, size_t, std::vector<char>>::value));
82-
ASSERT_TRUE((spsl::is_compatible_string<wchar_t, size_t, std::vector<wchar_t>>::value));
83-
ASSERT_FALSE((spsl::is_compatible_string<wchar_t, size_t, std::vector<char>>::value));
84-
ASSERT_FALSE((spsl::is_compatible_string<char, size_t, std::vector<wchar_t>>::value));
85-
86-
ASSERT_TRUE((spsl::is_compatible_string<char, size_t, spsl::ArrayString<32>>::value));
87-
ASSERT_TRUE((spsl::is_compatible_string<wchar_t, size_t, spsl::ArrayStringW<32>>::value));
88-
ASSERT_TRUE((spsl::is_compatible_string<char, size_t, spsl::PasswordString>::value));
89-
ASSERT_TRUE((spsl::is_compatible_string<wchar_t, size_t, spsl::PasswordStringW>::value));
90-
ASSERT_FALSE((spsl::is_compatible_string<wchar_t, size_t, spsl::ArrayString<32>>::value));
91-
ASSERT_FALSE((spsl::is_compatible_string<char, size_t, spsl::ArrayStringW<32>>::value));
92-
ASSERT_FALSE((spsl::is_compatible_string<wchar_t, size_t, spsl::PasswordString>::value));
93-
ASSERT_FALSE((spsl::is_compatible_string<char, size_t, spsl::PasswordStringW>::value));
114+
ASSERT_IS_COMPAT(char, size_t, std::string);
115+
ASSERT_IS_COMPAT(wchar_t, size_t, std::wstring);
116+
ASSERT_IS_NOT_COMPAT(wchar_t, size_t, std::string);
117+
ASSERT_IS_NOT_COMPAT(char, size_t, std::wstring);
118+
119+
ASSERT_IS_COMPAT(char, size_t, std::vector<char>);
120+
ASSERT_IS_COMPAT(wchar_t, size_t, std::vector<wchar_t>);
121+
ASSERT_IS_NOT_COMPAT(wchar_t, size_t, std::vector<char>);
122+
ASSERT_IS_NOT_COMPAT(char, size_t, std::vector<wchar_t>);
123+
124+
ASSERT_IS_COMPAT(char, size_t, spsl::ArrayString<32>);
125+
ASSERT_IS_COMPAT(wchar_t, size_t, spsl::ArrayStringW<32>);
126+
ASSERT_IS_COMPAT(char, size_t, spsl::PasswordString);
127+
ASSERT_IS_COMPAT(wchar_t, size_t, spsl::PasswordStringW);
128+
ASSERT_IS_NOT_COMPAT(wchar_t, size_t, spsl::ArrayString<32>);
129+
ASSERT_IS_NOT_COMPAT(char, size_t, spsl::ArrayStringW<32>);
130+
ASSERT_IS_NOT_COMPAT(wchar_t, size_t, spsl::PasswordString);
131+
ASSERT_IS_NOT_COMPAT(char, size_t, spsl::PasswordStringW);
94132

95133
#ifdef TEST_STRING_VIEW
96-
ASSERT_TRUE((spsl::is_compatible_string<char, size_t, std::experimental::string_view>::value));
97-
ASSERT_TRUE(
98-
(spsl::is_compatible_string<wchar_t, size_t, std::experimental::wstring_view>::value));
134+
ASSERT_IS_COMPAT(char, size_t, std::experimental::string_view);
135+
ASSERT_IS_COMPAT(wchar_t, size_t, std::experimental::wstring_view);
99136
#endif
100137

101-
ASSERT_FALSE((spsl::is_compatible_string<char, size_t, const char*>::value));
102-
ASSERT_FALSE((spsl::is_compatible_string<char, size_t, std::exception>::value));
103-
ASSERT_FALSE((spsl::is_compatible_string<char, size_t, std::vector<int>>::value));
138+
ASSERT_IS_NOT_COMPAT(char, size_t, const char*);
139+
ASSERT_IS_NOT_COMPAT(char, size_t, std::exception);
140+
ASSERT_IS_NOT_COMPAT(char, size_t, std::vector<int>);
104141
}

0 commit comments

Comments
 (0)