openMSX
StringOp_test.cc
Go to the documentation of this file.
1#include "catch.hpp"
2#include "StringOp.hh"
3#include "narrow.hh"
4#include <type_traits>
5
6using namespace StringOp;
7using std::string;
8using std::string_view;
9
10static void checkTrimRight(const string& s, char c, const string& expected)
11{
12 string test = s;
13 trimRight(test, c);
14 CHECK(test == expected);
15
16 string_view ref = s;
17 trimRight(ref, c);
18 CHECK(ref == expected);
19}
20static void checkTrimRight(const string& s, const char* chars, const string& expected)
21{
22 string test = s;
23 trimRight(test, chars);
24 CHECK(test == expected);
25
26 string_view ref = s;
27 trimRight(ref, chars);
28 CHECK(ref == expected);
29}
30
31static void checkTrimLeft(const string& s, char c, const string& expected)
32{
33 string test = s;
34 trimLeft(test, c);
35 CHECK(test == expected);
36
37 string_view ref = s;
38 trimLeft(ref, c);
39 CHECK(ref == expected);
40}
41static void checkTrimLeft(const string& s, const char* chars, const string& expected)
42{
43 string test = s;
44 trimLeft(test, chars);
45 CHECK(test == expected);
46
47 string_view ref = s;
48 trimLeft(ref, chars);
49 CHECK(ref == expected);
50}
51
52static void checkSplitOnFirst(const string& s, const string& first, const string& last)
53{
54 auto [f1, l1] = splitOnFirst(s, '-');
55 auto [f2, l2] = splitOnFirst(s, " -+");
56 static_assert(std::is_same_v<decltype(f1), std::string_view>);
57 static_assert(std::is_same_v<decltype(f2), std::string_view>);
58 static_assert(std::is_same_v<decltype(l1), std::string_view>);
59 static_assert(std::is_same_v<decltype(l2), std::string_view>);
60 CHECK(f1 == first);
61 CHECK(f2 == first);
62 CHECK(l1 == last);
63 CHECK(l2 == last);
64}
65
66static void checkSplitOnLast(const string& s, const string& first, const string& last)
67{
68 auto [f1, l1] = splitOnLast(s, '-');
69 auto [f2, l2] = splitOnLast(s, " -+");
70 static_assert(std::is_same_v<decltype(f1), std::string_view>);
71 static_assert(std::is_same_v<decltype(f2), std::string_view>);
72 static_assert(std::is_same_v<decltype(l1), std::string_view>);
73 static_assert(std::is_same_v<decltype(l2), std::string_view>);
74 CHECK(f1 == first);
75 CHECK(f2 == first);
76 CHECK(l1 == last);
77 CHECK(l2 == last);
78}
79
80static void checkSplit(const string& s, const std::vector<string_view> expected)
81{
82 //CHECK(split(s, '-') == expected);
83
84 std::vector<string_view> result;
85 for (const auto& ss : StringOp::split_view(s, '-')) {
86 result.push_back(ss);
87 }
88 CHECK(result == expected);
89}
90
91static void checkParseRange(const string& s, const std::vector<unsigned>& expected)
92{
93 auto parsed = parseRange(s, 0, 63);
94 std::vector<unsigned> result;
95 parsed.foreachSetBit([&](size_t i) { result.push_back(narrow<unsigned>(i)); });
96 CHECK(result == expected);
97}
98
99
100TEST_CASE("StringOp")
101{
102 SECTION("stringTo<int>") {
103 std::optional<int> NOK;
104 using OK = std::optional<int>;
105
106 // empty string is invalid
107 CHECK(StringOp::stringTo<int>("") == NOK);
108
109 // valid decimal values, positive ..
110 CHECK(StringOp::stringTo<int>("0") == OK(0));
111 CHECK(StringOp::stringTo<int>("03") == OK(3));
112 CHECK(StringOp::stringTo<int>("097") == OK(97));
113 CHECK(StringOp::stringTo<int>("12") == OK(12));
114 // .. and negative
115 CHECK(StringOp::stringTo<int>("-0") == OK(0));
116 CHECK(StringOp::stringTo<int>("-11") == OK(-11));
117
118 // invalid
119 CHECK(StringOp::stringTo<int>("-") == NOK);
120 CHECK(StringOp::stringTo<int>("zz") == NOK);
121 CHECK(StringOp::stringTo<int>("+") == NOK);
122 CHECK(StringOp::stringTo<int>("+12") == NOK);
123
124 // leading whitespace is invalid, trailing stuff is invalid
125 CHECK(StringOp::stringTo<int>(" 14") == NOK);
126 CHECK(StringOp::stringTo<int>("15 ") == NOK);
127 CHECK(StringOp::stringTo<int>("15bar") == NOK);
128
129 // hexadecimal
130 CHECK(StringOp::stringTo<int>("0x1a") == OK(26));
131 CHECK(StringOp::stringTo<int>("0x1B") == OK(27));
132 CHECK(StringOp::stringTo<int>("0X1c") == OK(28));
133 CHECK(StringOp::stringTo<int>("0X1D") == OK(29));
134 CHECK(StringOp::stringTo<int>("-0x100") == OK(-256));
135 CHECK(StringOp::stringTo<int>("0x") == NOK);
136 CHECK(StringOp::stringTo<int>("0x12g") == NOK);
137 CHECK(StringOp::stringTo<int>("0x-123") == NOK);
138
139 // binary
140 CHECK(StringOp::stringTo<int>("0b") == NOK);
141 CHECK(StringOp::stringTo<int>("0b2") == NOK);
142 CHECK(StringOp::stringTo<int>("0b100") == OK(4));
143 CHECK(StringOp::stringTo<int>("-0B1001") == OK(-9));
144 CHECK(StringOp::stringTo<int>("0b-11") == NOK);
145
146 // overflow
147 CHECK(StringOp::stringTo<int>("-2147483649") == NOK);
148 CHECK(StringOp::stringTo<int>("2147483648") == NOK);
149 CHECK(StringOp::stringTo<int>("999999999999999") == NOK);
150 CHECK(StringOp::stringTo<int>("-999999999999999") == NOK);
151 // edge cases (no overflow)
152 CHECK(StringOp::stringTo<int>("-2147483648") == OK(-2147483648));
153 CHECK(StringOp::stringTo<int>("2147483647") == OK(2147483647));
154 CHECK(StringOp::stringTo<int>("-0x80000000") == OK(-2147483648));
155 CHECK(StringOp::stringTo<int>("0x7fffffff") == OK(2147483647));
156 }
157 SECTION("stringTo<unsigned>") {
158 std::optional<unsigned> NOK;
159 using OK = std::optional<unsigned>;
160
161 // empty string is invalid
162 CHECK(StringOp::stringTo<unsigned>("") == NOK);
163
164 // valid decimal values, only positive ..
165 CHECK(StringOp::stringTo<unsigned>("0") == OK(0));
166 CHECK(StringOp::stringTo<unsigned>("08") == OK(8));
167 CHECK(StringOp::stringTo<unsigned>("0123") == OK(123));
168 CHECK(StringOp::stringTo<unsigned>("13") == OK(13));
169 // negative is invalid
170 CHECK(StringOp::stringTo<unsigned>("-0") == NOK);
171 CHECK(StringOp::stringTo<unsigned>("-12") == NOK);
172
173 // invalid
174 CHECK(StringOp::stringTo<unsigned>("-") == NOK);
175 CHECK(StringOp::stringTo<unsigned>("zz") == NOK);
176 CHECK(StringOp::stringTo<unsigned>("+") == NOK);
177 CHECK(StringOp::stringTo<unsigned>("+12") == NOK);
178
179 // leading whitespace is invalid, trailing stuff is invalid
180 CHECK(StringOp::stringTo<unsigned>(" 16") == NOK);
181 CHECK(StringOp::stringTo<unsigned>("17 ") == NOK);
182 CHECK(StringOp::stringTo<unsigned>("17qux") == NOK);
183
184 // hexadecimal
185 CHECK(StringOp::stringTo<unsigned>("0x2a") == OK(42));
186 CHECK(StringOp::stringTo<unsigned>("0x2B") == OK(43));
187 CHECK(StringOp::stringTo<unsigned>("0X2c") == OK(44));
188 CHECK(StringOp::stringTo<unsigned>("0X2D") == OK(45));
189 CHECK(StringOp::stringTo<unsigned>("0x") == NOK);
190 CHECK(StringOp::stringTo<unsigned>("-0x456") == NOK);
191 CHECK(StringOp::stringTo<unsigned>("0x-123") == NOK);
192
193 // binary
194 CHECK(StringOp::stringTo<unsigned>("0b1100") == OK(12));
195 CHECK(StringOp::stringTo<unsigned>("0B1010") == OK(10));
196 CHECK(StringOp::stringTo<unsigned>("0b") == NOK);
197 CHECK(StringOp::stringTo<unsigned>("-0b101") == NOK);
198 CHECK(StringOp::stringTo<unsigned>("0b2") == NOK);
199 CHECK(StringOp::stringTo<unsigned>("0b-11") == NOK);
200
201 // overflow
202 CHECK(StringOp::stringTo<unsigned>("4294967296") == NOK);
203 CHECK(StringOp::stringTo<unsigned>("999999999999999") == NOK);
204 // edge case (no overflow)
205 CHECK(StringOp::stringTo<unsigned>("4294967295") == OK(4294967295));
206 CHECK(StringOp::stringTo<unsigned>("0xffffffff") == OK(4294967295));
207 }
208
209 SECTION("stringToBool") {
210 CHECK(stringToBool("0") == false);
211 CHECK(stringToBool("1") == true);
212 CHECK(stringToBool("Yes") == true);
213 CHECK(stringToBool("yes") == true);
214 CHECK(stringToBool("YES") == true);
215 CHECK(stringToBool("No") == false);
216 CHECK(stringToBool("no") == false);
217 CHECK(stringToBool("NO") == false);
218 CHECK(stringToBool("True") == true);
219 CHECK(stringToBool("true") == true);
220 CHECK(stringToBool("TRUE") == true);
221 CHECK(stringToBool("False") == false);
222 CHECK(stringToBool("false") == false);
223 CHECK(stringToBool("FALSE") == false);
224 // These two behave different as Tcl
225 CHECK(stringToBool("2") == false); // is true in Tcl
226 CHECK(stringToBool("foobar") == false); // is error in Tcl
227 }
228 /*SECTION("toLower") {
229 CHECK(toLower("") == "");
230 CHECK(toLower("foo") == "foo");
231 CHECK(toLower("FOO") == "foo");
232 CHECK(toLower("fOo") == "foo");
233 CHECK(toLower(string("FoO")) == "foo");
234 }*/
235 SECTION("trimRight") {
236 checkTrimRight("", ' ', "");
237 checkTrimRight(" ", ' ', "");
238 checkTrimRight("foo", ' ', "foo");
239 checkTrimRight(" foo", ' ', " foo");
240 checkTrimRight("foo ", ' ', "foo");
241
242 checkTrimRight("", "o ", "");
243 checkTrimRight(" o ", "o ", "");
244 checkTrimRight("foobar", "o ", "foobar");
245 checkTrimRight(" foobar", "o ", " foobar");
246 checkTrimRight("foo ", "o ", "f");
247 }
248 SECTION("trimLeft") {
249 checkTrimLeft("", ' ', "");
250 checkTrimLeft(" ", ' ', "");
251 checkTrimLeft("foo", ' ', "foo");
252 checkTrimLeft("foo ", ' ', "foo ");
253 checkTrimLeft(" foo", ' ', "foo");
254
255 checkTrimLeft("", "f ", "");
256 checkTrimLeft(" f ", "f ", "");
257 checkTrimLeft("foo", "f ", "oo");
258 checkTrimLeft("barfoo ", "f ", "barfoo ");
259 checkTrimLeft(" foo", "f ", "oo");
260 }
261 SECTION("splitOnFirst") {
262 checkSplitOnFirst("", "", "");
263 checkSplitOnFirst("-", "", "");
264 checkSplitOnFirst("foo-", "foo", "");
265 checkSplitOnFirst("-foo", "", "foo");
266 checkSplitOnFirst("foo-bar", "foo", "bar");
267 checkSplitOnFirst("foo-bar-qux", "foo", "bar-qux");
268 checkSplitOnFirst("-bar-qux", "", "bar-qux");
269 checkSplitOnFirst("foo-bar-", "foo", "bar-");
270 }
271 SECTION("splitOnLast") {
272 checkSplitOnLast("", "", "");
273 checkSplitOnLast("-", "", "");
274 checkSplitOnLast("foo-", "foo", "");
275 checkSplitOnLast("-foo", "", "foo");
276 checkSplitOnLast("foo-bar", "foo", "bar");
277 checkSplitOnLast("foo-bar-qux", "foo-bar", "qux");
278 checkSplitOnLast("-bar-qux", "-bar", "qux");
279 checkSplitOnLast("foo-bar-", "foo-bar", "");
280 }
281 SECTION("split") {
282 checkSplit("", {});
283 checkSplit("-", {""});
284 checkSplit("foo-", {"foo"});
285 checkSplit("-foo", {"", "foo"});
286 checkSplit("foo-bar", {"foo", "bar"});
287 checkSplit("foo-bar-qux", {"foo", "bar", "qux"});
288 checkSplit("-bar-qux", {"", "bar", "qux"});
289 checkSplit("foo-bar-", {"foo", "bar"});
290 }
291 SECTION("parseRange") {
292 checkParseRange("", {});
293 checkParseRange("5", {5});
294 checkParseRange("5,8", {5,8});
295 checkParseRange("5,5", {5});
296 checkParseRange("5-7", {5,6,7});
297 checkParseRange("7-5", {5,6,7});
298 checkParseRange("5-7,19", {5,6,7,19});
299 checkParseRange("15,5-7", {5,6,7,15});
300 checkParseRange("6,5-7", {5,6,7});
301 checkParseRange("5-8,10-12", {5,6,7,8,10,11,12});
302 checkParseRange("5-9,6-10", {5,6,7,8,9,10});
303
304 CHECK_THROWS (parseRange( "4", 5, 10));
305 CHECK_NOTHROW(parseRange( "5", 5, 10));
306 CHECK_NOTHROW(parseRange("10", 5, 10));
307 CHECK_THROWS (parseRange("11", 5, 10));
308 }
309 SECTION("caseless") {
310 caseless op;
311 CHECK( op("abc", "xyz"));
312 CHECK(!op("xyz", "abc"));
313 CHECK(!op("abc", "abc"));
314 CHECK( op("ABC", "xyz"));
315 CHECK(!op("xyz", "ABC"));
316 CHECK(!op("ABC", "abc"));
317 CHECK( op("aBC", "Xyz"));
318 CHECK(!op("xYz", "AbC"));
319 CHECK(!op("ABc", "abC"));
320
321 CHECK( op("abc", "ABCdef"));
322 CHECK(!op("AbcDef", "AbC"));
323 }
324 SECTION("casecmp") {
325 casecmp op;
326 CHECK( op("abc", "abc"));
327 CHECK( op("abc", "ABC"));
328 CHECK(!op("abc", "xyz"));
329 CHECK(!op("ab", "abc"));
330 CHECK(!op("ab", "ABC"));
331 CHECK(!op("abc", "ab"));
332 CHECK(!op("abc", "AB"));
333 }
334}
test
void test(const IterableBitSet< N > &s, std::initializer_list< size_t > list)
Definition: IterableBitSet_test.cc:19
TEST_CASE
TEST_CASE("StringOp")
Definition: StringOp_test.cc:100
CHECK
CHECK(m3==m3)
StringOp::parseRange
IterableBitSet< 64 > parseRange(string_view str, unsigned min, unsigned max)
Definition: StringOp.cc:177
StringOp::stringToBool
bool stringToBool(string_view str)
Definition: StringOp.cc:12
StringOp::splitOnLast
std::pair< string_view, string_view > splitOnLast(string_view str, string_view chars)
Definition: StringOp.cc:108
StringOp::trimRight
void trimRight(string &str, const char *chars)
Definition: StringOp.cc:29
StringOp::splitOnFirst
std::pair< string_view, string_view > splitOnFirst(string_view str, string_view chars)
Definition: StringOp.cc:91
StringOp::trimLeft
void trimLeft(string &str, const char *chars)
Definition: StringOp.cc:58
StringOp::split_view
auto split_view(std::string_view str, char c)
Definition: StringOp.hh:78
Generated on Thu Mar 30 2023 22:15:35 for openMSX by doxygen 1.9.4