1 //
2 // Automated Testing Framework (atf)
3 //
4 // Copyright (c) 2007 The NetBSD Foundation, Inc.
5 // All rights reserved.
6 //
7 // Redistribution and use in source and binary forms, with or without
8 // modification, are permitted provided that the following conditions
9 // are met:
10 // 1. Redistributions of source code must retain the above copyright
11 // notice, this list of conditions and the following disclaimer.
12 // 2. Redistributions in binary form must reproduce the above copyright
13 // notice, this list of conditions and the following disclaimer in the
14 // documentation and/or other materials provided with the distribution.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 //
29
30 #include <cstring>
31 #include <set>
32 #include <vector>
33
34 #include <atf-c++.hpp>
35
36 #include "text.hpp"
37
38 // ------------------------------------------------------------------------
39 // Test cases for the free functions.
40 // ------------------------------------------------------------------------
41
42 ATF_TEST_CASE(duplicate);
ATF_TEST_CASE_HEAD(duplicate)43 ATF_TEST_CASE_HEAD(duplicate)
44 {
45 set_md_var("descr", "Tests the duplicate function");
46 }
ATF_TEST_CASE_BODY(duplicate)47 ATF_TEST_CASE_BODY(duplicate)
48 {
49 using tools::text::duplicate;
50
51 const char* orig = "foo";
52
53 char* copy = duplicate(orig);
54 ATF_REQUIRE_EQ(std::strlen(copy), 3);
55 ATF_REQUIRE(std::strcmp(copy, "foo") == 0);
56
57 std::strcpy(copy, "bar");
58 ATF_REQUIRE(std::strcmp(copy, "bar") == 0);
59 ATF_REQUIRE(std::strcmp(orig, "foo") == 0);
60 }
61
62 ATF_TEST_CASE(join);
ATF_TEST_CASE_HEAD(join)63 ATF_TEST_CASE_HEAD(join)
64 {
65 set_md_var("descr", "Tests the join function");
66 }
ATF_TEST_CASE_BODY(join)67 ATF_TEST_CASE_BODY(join)
68 {
69 using tools::text::join;
70
71 // First set of tests using a non-sorted collection, std::vector.
72 {
73 std::vector< std::string > words;
74 std::string str;
75
76 words.clear();
77 str = join(words, ",");
78 ATF_REQUIRE_EQ(str, "");
79
80 words.clear();
81 words.push_back("");
82 str = join(words, ",");
83 ATF_REQUIRE_EQ(str, "");
84
85 words.clear();
86 words.push_back("");
87 words.push_back("");
88 str = join(words, ",");
89 ATF_REQUIRE_EQ(str, ",");
90
91 words.clear();
92 words.push_back("foo");
93 words.push_back("");
94 words.push_back("baz");
95 str = join(words, ",");
96 ATF_REQUIRE_EQ(str, "foo,,baz");
97
98 words.clear();
99 words.push_back("foo");
100 words.push_back("bar");
101 words.push_back("baz");
102 str = join(words, ",");
103 ATF_REQUIRE_EQ(str, "foo,bar,baz");
104 }
105
106 // Second set of tests using a sorted collection, std::set.
107 {
108 std::set< std::string > words;
109 std::string str;
110
111 words.clear();
112 str = join(words, ",");
113 ATF_REQUIRE_EQ(str, "");
114
115 words.clear();
116 words.insert("");
117 str = join(words, ",");
118 ATF_REQUIRE_EQ(str, "");
119
120 words.clear();
121 words.insert("foo");
122 words.insert("");
123 words.insert("baz");
124 str = join(words, ",");
125 ATF_REQUIRE_EQ(str, ",baz,foo");
126
127 words.clear();
128 words.insert("foo");
129 words.insert("bar");
130 words.insert("baz");
131 str = join(words, ",");
132 ATF_REQUIRE_EQ(str, "bar,baz,foo");
133 }
134 }
135
136 ATF_TEST_CASE(match);
ATF_TEST_CASE_HEAD(match)137 ATF_TEST_CASE_HEAD(match)
138 {
139 set_md_var("descr", "Tests the match function");
140 }
ATF_TEST_CASE_BODY(match)141 ATF_TEST_CASE_BODY(match)
142 {
143 using tools::text::match;
144
145 ATF_REQUIRE_THROW(std::runtime_error, match("", "["));
146
147 ATF_REQUIRE(match("", ""));
148 ATF_REQUIRE(!match("foo", ""));
149
150 ATF_REQUIRE(match("", ".*"));
151 ATF_REQUIRE(match("", "[a-z]*"));
152
153 ATF_REQUIRE(match("hello", "hello"));
154 ATF_REQUIRE(match("hello", "[a-z]+"));
155 ATF_REQUIRE(match("hello", "^[a-z]+$"));
156
157 ATF_REQUIRE(!match("hello", "helooo"));
158 ATF_REQUIRE(!match("hello", "[a-z]+5"));
159 ATF_REQUIRE(!match("hello", "^ [a-z]+$"));
160 }
161
162 ATF_TEST_CASE(split);
ATF_TEST_CASE_HEAD(split)163 ATF_TEST_CASE_HEAD(split)
164 {
165 set_md_var("descr", "Tests the split function");
166 }
ATF_TEST_CASE_BODY(split)167 ATF_TEST_CASE_BODY(split)
168 {
169 using tools::text::split;
170
171 std::vector< std::string > words;
172
173 words = split("", " ");
174 ATF_REQUIRE_EQ(words.size(), 0);
175
176 words = split(" ", " ");
177 ATF_REQUIRE_EQ(words.size(), 0);
178
179 words = split(" ", " ");
180 ATF_REQUIRE_EQ(words.size(), 0);
181
182 words = split("a b", " ");
183 ATF_REQUIRE_EQ(words.size(), 2);
184 ATF_REQUIRE_EQ(words[0], "a");
185 ATF_REQUIRE_EQ(words[1], "b");
186
187 words = split("a b c d", " ");
188 ATF_REQUIRE_EQ(words.size(), 4);
189 ATF_REQUIRE_EQ(words[0], "a");
190 ATF_REQUIRE_EQ(words[1], "b");
191 ATF_REQUIRE_EQ(words[2], "c");
192 ATF_REQUIRE_EQ(words[3], "d");
193
194 words = split("foo bar", " ");
195 ATF_REQUIRE_EQ(words.size(), 2);
196 ATF_REQUIRE_EQ(words[0], "foo");
197 ATF_REQUIRE_EQ(words[1], "bar");
198
199 words = split("foo bar baz foobar", " ");
200 ATF_REQUIRE_EQ(words.size(), 4);
201 ATF_REQUIRE_EQ(words[0], "foo");
202 ATF_REQUIRE_EQ(words[1], "bar");
203 ATF_REQUIRE_EQ(words[2], "baz");
204 ATF_REQUIRE_EQ(words[3], "foobar");
205
206 words = split(" foo bar", " ");
207 ATF_REQUIRE_EQ(words.size(), 2);
208 ATF_REQUIRE_EQ(words[0], "foo");
209 ATF_REQUIRE_EQ(words[1], "bar");
210
211 words = split("foo bar", " ");
212 ATF_REQUIRE_EQ(words.size(), 2);
213 ATF_REQUIRE_EQ(words[0], "foo");
214 ATF_REQUIRE_EQ(words[1], "bar");
215
216 words = split("foo bar ", " ");
217 ATF_REQUIRE_EQ(words.size(), 2);
218 ATF_REQUIRE_EQ(words[0], "foo");
219 ATF_REQUIRE_EQ(words[1], "bar");
220
221 words = split(" foo bar ", " ");
222 ATF_REQUIRE_EQ(words.size(), 2);
223 ATF_REQUIRE_EQ(words[0], "foo");
224 ATF_REQUIRE_EQ(words[1], "bar");
225 }
226
227 ATF_TEST_CASE(split_delims);
ATF_TEST_CASE_HEAD(split_delims)228 ATF_TEST_CASE_HEAD(split_delims)
229 {
230 set_md_var("descr", "Tests the split function using different delimiters");
231 }
ATF_TEST_CASE_BODY(split_delims)232 ATF_TEST_CASE_BODY(split_delims)
233 {
234 using tools::text::split;
235
236 std::vector< std::string > words;
237
238 words = split("", "/");
239 ATF_REQUIRE_EQ(words.size(), 0);
240
241 words = split(" ", "/");
242 ATF_REQUIRE_EQ(words.size(), 1);
243 ATF_REQUIRE_EQ(words[0], " ");
244
245 words = split(" ", "/");
246 ATF_REQUIRE_EQ(words.size(), 1);
247 ATF_REQUIRE_EQ(words[0], " ");
248
249 words = split("a/b", "/");
250 ATF_REQUIRE_EQ(words.size(), 2);
251 ATF_REQUIRE_EQ(words[0], "a");
252 ATF_REQUIRE_EQ(words[1], "b");
253
254 words = split("aLONGDELIMbcdLONGDELIMef", "LONGDELIM");
255 ATF_REQUIRE_EQ(words.size(), 3);
256 ATF_REQUIRE_EQ(words[0], "a");
257 ATF_REQUIRE_EQ(words[1], "bcd");
258 ATF_REQUIRE_EQ(words[2], "ef");
259 }
260
261 ATF_TEST_CASE(trim);
ATF_TEST_CASE_HEAD(trim)262 ATF_TEST_CASE_HEAD(trim)
263 {
264 set_md_var("descr", "Tests the trim function");
265 }
ATF_TEST_CASE_BODY(trim)266 ATF_TEST_CASE_BODY(trim)
267 {
268 using tools::text::trim;
269
270 ATF_REQUIRE_EQ(trim(""), "");
271 ATF_REQUIRE_EQ(trim(" "), "");
272 ATF_REQUIRE_EQ(trim("\t"), "");
273
274 ATF_REQUIRE_EQ(trim(" foo"), "foo");
275 ATF_REQUIRE_EQ(trim("\t foo"), "foo");
276 ATF_REQUIRE_EQ(trim(" \tfoo"), "foo");
277 ATF_REQUIRE_EQ(trim("foo\t "), "foo");
278 ATF_REQUIRE_EQ(trim("foo \t"), "foo");
279
280 ATF_REQUIRE_EQ(trim("foo bar"), "foo bar");
281 ATF_REQUIRE_EQ(trim("\t foo bar"), "foo bar");
282 ATF_REQUIRE_EQ(trim(" \tfoo bar"), "foo bar");
283 ATF_REQUIRE_EQ(trim("foo bar\t "), "foo bar");
284 ATF_REQUIRE_EQ(trim("foo bar \t"), "foo bar");
285 }
286
287 ATF_TEST_CASE(to_bool);
ATF_TEST_CASE_HEAD(to_bool)288 ATF_TEST_CASE_HEAD(to_bool)
289 {
290 set_md_var("descr", "Tests the to_string function");
291 }
ATF_TEST_CASE_BODY(to_bool)292 ATF_TEST_CASE_BODY(to_bool)
293 {
294 using tools::text::to_bool;
295
296 ATF_REQUIRE(to_bool("true"));
297 ATF_REQUIRE(to_bool("TRUE"));
298 ATF_REQUIRE(to_bool("yes"));
299 ATF_REQUIRE(to_bool("YES"));
300
301 ATF_REQUIRE(!to_bool("false"));
302 ATF_REQUIRE(!to_bool("FALSE"));
303 ATF_REQUIRE(!to_bool("no"));
304 ATF_REQUIRE(!to_bool("NO"));
305
306 ATF_REQUIRE_THROW(std::runtime_error, to_bool(""));
307 ATF_REQUIRE_THROW(std::runtime_error, to_bool("tru"));
308 ATF_REQUIRE_THROW(std::runtime_error, to_bool("true2"));
309 ATF_REQUIRE_THROW(std::runtime_error, to_bool("fals"));
310 ATF_REQUIRE_THROW(std::runtime_error, to_bool("false2"));
311 }
312
313 ATF_TEST_CASE(to_bytes);
ATF_TEST_CASE_HEAD(to_bytes)314 ATF_TEST_CASE_HEAD(to_bytes)
315 {
316 set_md_var("descr", "Tests the to_bytes function");
317 }
ATF_TEST_CASE_BODY(to_bytes)318 ATF_TEST_CASE_BODY(to_bytes)
319 {
320 using tools::text::to_bytes;
321
322 ATF_REQUIRE_EQ(0, to_bytes("0"));
323 ATF_REQUIRE_EQ(12345, to_bytes("12345"));
324 ATF_REQUIRE_EQ(2 * 1024, to_bytes("2k"));
325 ATF_REQUIRE_EQ(4 * 1024 * 1024, to_bytes("4m"));
326 ATF_REQUIRE_EQ(int64_t(8) * 1024 * 1024 * 1024, to_bytes("8g"));
327 ATF_REQUIRE_EQ(int64_t(16) * 1024 * 1024 * 1024 * 1024, to_bytes("16t"));
328
329 ATF_REQUIRE_THROW_RE(std::runtime_error, "Empty", to_bytes(""));
330 ATF_REQUIRE_THROW_RE(std::runtime_error, "Unknown size unit 'd'",
331 to_bytes("12d"));
332 ATF_REQUIRE_THROW(std::runtime_error, to_bytes(" "));
333 ATF_REQUIRE_THROW(std::runtime_error, to_bytes(" k"));
334 }
335
336 ATF_TEST_CASE(to_string);
ATF_TEST_CASE_HEAD(to_string)337 ATF_TEST_CASE_HEAD(to_string)
338 {
339 set_md_var("descr", "Tests the to_string function");
340 }
ATF_TEST_CASE_BODY(to_string)341 ATF_TEST_CASE_BODY(to_string)
342 {
343 using tools::text::to_string;
344
345 ATF_REQUIRE_EQ(to_string('a'), "a");
346 ATF_REQUIRE_EQ(to_string("a"), "a");
347 ATF_REQUIRE_EQ(to_string(5), "5");
348 }
349
350 ATF_TEST_CASE(to_type);
ATF_TEST_CASE_HEAD(to_type)351 ATF_TEST_CASE_HEAD(to_type)
352 {
353 set_md_var("descr", "Tests the to_type function");
354 }
ATF_TEST_CASE_BODY(to_type)355 ATF_TEST_CASE_BODY(to_type)
356 {
357 using tools::text::to_type;
358
359 ATF_REQUIRE_EQ(to_type< int >("0"), 0);
360 ATF_REQUIRE_EQ(to_type< int >("1234"), 1234);
361 ATF_REQUIRE_THROW(std::runtime_error, to_type< int >(" "));
362 ATF_REQUIRE_THROW(std::runtime_error, to_type< int >("0 a"));
363 ATF_REQUIRE_THROW(std::runtime_error, to_type< int >("a"));
364
365 ATF_REQUIRE_EQ(to_type< float >("0.5"), 0.5);
366 ATF_REQUIRE_EQ(to_type< float >("1234.5"), 1234.5);
367 ATF_REQUIRE_THROW(std::runtime_error, to_type< float >("0.5 a"));
368 ATF_REQUIRE_THROW(std::runtime_error, to_type< float >("a"));
369
370 ATF_REQUIRE_EQ(to_type< std::string >("a"), "a");
371 }
372
373 // ------------------------------------------------------------------------
374 // Main.
375 // ------------------------------------------------------------------------
376
ATF_INIT_TEST_CASES(tcs)377 ATF_INIT_TEST_CASES(tcs)
378 {
379 // Add the test cases for the free functions.
380 ATF_ADD_TEST_CASE(tcs, duplicate);
381 ATF_ADD_TEST_CASE(tcs, join);
382 ATF_ADD_TEST_CASE(tcs, match);
383 ATF_ADD_TEST_CASE(tcs, split);
384 ATF_ADD_TEST_CASE(tcs, split_delims);
385 ATF_ADD_TEST_CASE(tcs, trim);
386 ATF_ADD_TEST_CASE(tcs, to_bool);
387 ATF_ADD_TEST_CASE(tcs, to_bytes);
388 ATF_ADD_TEST_CASE(tcs, to_string);
389 ATF_ADD_TEST_CASE(tcs, to_type);
390 }
391