2
|
1 /* |
0
|
2 * main.cpp -- main test file for unicode |
|
3 * |
5
|
4 * Copyright (c) 2013-2018 David Demelier <markand@malikania.fr> |
0
|
5 * |
|
6 * Permission to use, copy, modify, and/or distribute this software for any |
|
7 * purpose with or without fee is hereby granted, provided that the above |
|
8 * copyright notice and this permission notice appear in all copies. |
|
9 * |
|
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
|
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
|
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
|
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
|
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
|
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
|
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
17 */ |
|
18 |
|
19 /* |
|
20 * /!\ Be sure to keep this file with UTF-8 encoding /!\ |
|
21 */ |
|
22 |
4
|
23 #define BOOST_TEST_MODULE "libunicode" |
|
24 #include <boost/test/unit_test.hpp> |
0
|
25 |
|
26 #include <unicode.hpp> |
|
27 |
4
|
28 namespace { |
|
29 |
9
|
30 auto equals(const std::u32string& s1, const std::u32string& s2) -> bool |
4
|
31 { |
9
|
32 return s1 == s2; |
4
|
33 } |
|
34 |
0
|
35 /* |
|
36 * Conversion UTF32 -> UTF8 |
|
37 * ------------------------------------------------------------------ |
|
38 */ |
|
39 |
4
|
40 BOOST_AUTO_TEST_SUITE(convert_32_to_8) |
|
41 |
|
42 BOOST_AUTO_TEST_CASE(ascii) |
0
|
43 { |
9
|
44 std::u32string u32{'a', 'b', 'c'}; |
|
45 std::string s = unicode::to_utf8(u32); |
0
|
46 |
9
|
47 BOOST_TEST(s == "abc"); |
0
|
48 } |
|
49 |
4
|
50 BOOST_AUTO_TEST_CASE(valid) |
0
|
51 { |
9
|
52 std::u32string u32{'a', U'é', 'c', U'𠀀'}; |
|
53 std::string s = unicode::to_utf8(u32); |
|
54 std::string expected = u8"aéc𠀀"; |
0
|
55 |
9
|
56 BOOST_TEST(s == expected); |
0
|
57 } |
|
58 |
4
|
59 BOOST_AUTO_TEST_CASE(invalid) |
0
|
60 { |
9
|
61 std::u32string u32{'a', 0xFFFFFFFF, 'c'}; |
0
|
62 |
9
|
63 BOOST_REQUIRE_THROW(unicode::to_utf8(u32), std::exception); |
0
|
64 } |
|
65 |
4
|
66 BOOST_AUTO_TEST_SUITE_END() |
|
67 |
0
|
68 /* |
|
69 * Conversion UTF8 -> UTF32 |
|
70 * ------------------------------------------------------------------ |
|
71 */ |
|
72 |
4
|
73 BOOST_AUTO_TEST_SUITE(convert_8_to_32) |
|
74 |
|
75 BOOST_AUTO_TEST_CASE(ascii) |
0
|
76 { |
9
|
77 std::string s{"abc"}; |
|
78 std::u32string expected{'a', 'b', 'c'}; |
|
79 std::u32string result = unicode::to_utf32(s); |
0
|
80 |
9
|
81 BOOST_TEST(equals(result, expected)); |
0
|
82 } |
|
83 |
4
|
84 BOOST_AUTO_TEST_CASE(valid) |
0
|
85 { |
9
|
86 std::string s{u8"aéc𠀀"}; |
|
87 std::u32string expected{'a', U'é', 'c', U'𠀀'}; |
|
88 std::u32string result = unicode::to_utf32(s); |
0
|
89 |
9
|
90 BOOST_TEST(equals(result, expected)); |
0
|
91 } |
|
92 |
4
|
93 BOOST_AUTO_TEST_SUITE_END() |
|
94 |
0
|
95 /* |
|
96 * UTF32 to upper |
|
97 * ------------------------------------------------------------------ |
|
98 */ |
|
99 |
4
|
100 BOOST_AUTO_TEST_SUITE(toupper_32) |
|
101 |
|
102 BOOST_AUTO_TEST_CASE(ascii) |
0
|
103 { |
9
|
104 std::u32string u32{'a', 'b', 'c'}; |
|
105 std::u32string expected{'A', 'B', 'C'}; |
|
106 std::u32string result = unicode::toupper(u32); |
0
|
107 |
9
|
108 BOOST_TEST(equals(result, expected)); |
0
|
109 } |
|
110 |
4
|
111 BOOST_AUTO_TEST_CASE(valid) |
0
|
112 { |
9
|
113 std::u32string u32{U'ä', U'ç', U'ë'}; |
|
114 std::u32string expected{U'Ä', U'Ç', U'Ë'}; |
|
115 std::u32string result = unicode::toupper(u32); |
0
|
116 |
9
|
117 BOOST_TEST(equals(result, expected)); |
0
|
118 } |
|
119 |
4
|
120 BOOST_AUTO_TEST_CASE(invalid) |
0
|
121 { |
9
|
122 std::u32string u32{'a', 0xFFFFFFFF, 'b'}; |
|
123 std::u32string expected{'A', 0xFFFFFFFF, 'B'}; |
|
124 std::u32string result = unicode::toupper(u32); |
0
|
125 |
9
|
126 BOOST_TEST(equals(result, expected)); |
0
|
127 } |
|
128 |
4
|
129 BOOST_AUTO_TEST_SUITE_END() |
|
130 |
0
|
131 /* |
|
132 * UTF32 to lower |
|
133 * ------------------------------------------------------------------ |
|
134 */ |
|
135 |
4
|
136 BOOST_AUTO_TEST_SUITE(tolower_32) |
|
137 |
|
138 BOOST_AUTO_TEST_CASE(ascii) |
0
|
139 { |
9
|
140 std::u32string u32{'A', 'B', 'C'}; |
|
141 std::u32string expected{'a', 'b', 'c'}; |
|
142 std::u32string result = unicode::tolower(u32); |
0
|
143 |
9
|
144 BOOST_TEST(equals(result, expected)); |
0
|
145 } |
|
146 |
4
|
147 BOOST_AUTO_TEST_CASE(valid) |
0
|
148 { |
9
|
149 std::u32string u32{U'Ä', U'Ç', U'Ë'}; |
|
150 std::u32string expected{U'ä', U'ç', U'ë'}; |
|
151 std::u32string result = unicode::tolower(u32); |
0
|
152 |
9
|
153 BOOST_TEST(equals(result, expected)); |
0
|
154 } |
|
155 |
4
|
156 BOOST_AUTO_TEST_CASE(invalid) |
0
|
157 { |
9
|
158 std::u32string u32{'A', 0xFFFFFFFF, 'B'}; |
|
159 std::u32string expected{'a', 0xFFFFFFFF, 'b'}; |
|
160 std::u32string result = unicode::tolower(u32); |
0
|
161 |
9
|
162 BOOST_TEST(equals(result, expected)); |
0
|
163 } |
|
164 |
4
|
165 BOOST_AUTO_TEST_SUITE_END() |
|
166 |
0
|
167 /* |
|
168 * UTF8 to upper |
|
169 * ------------------------------------------------------------------ |
|
170 */ |
|
171 |
4
|
172 BOOST_AUTO_TEST_SUITE(toupper_8) |
|
173 |
|
174 BOOST_AUTO_TEST_CASE(ascii) |
0
|
175 { |
9
|
176 std::string s{"abc"}; |
|
177 std::string r = unicode::toupper(s); |
0
|
178 |
9
|
179 BOOST_TEST(r == "ABC"); |
0
|
180 } |
|
181 |
4
|
182 BOOST_AUTO_TEST_CASE(valid) |
0
|
183 { |
9
|
184 std::string s{u8"aéc"}; |
|
185 std::string r = unicode::toupper(s); |
0
|
186 |
9
|
187 BOOST_TEST(r == u8"AÉC"); |
0
|
188 } |
|
189 |
4
|
190 BOOST_AUTO_TEST_CASE(invalid) |
0
|
191 { |
9
|
192 std::string s{"a" "\xFF""b"}; |
0
|
193 |
9
|
194 BOOST_REQUIRE_THROW(unicode::toupper(s), std::exception); |
0
|
195 } |
|
196 |
4
|
197 BOOST_AUTO_TEST_SUITE_END() |
|
198 |
0
|
199 /* |
|
200 * UTF8 to lower |
|
201 * ------------------------------------------------------------------ |
|
202 */ |
|
203 |
4
|
204 BOOST_AUTO_TEST_SUITE(tolower_8) |
|
205 |
|
206 BOOST_AUTO_TEST_CASE(ascii) |
0
|
207 { |
9
|
208 std::string s{"ABC"}; |
|
209 std::string r = unicode::tolower(s); |
0
|
210 |
9
|
211 BOOST_TEST(r == "abc"); |
0
|
212 } |
|
213 |
4
|
214 BOOST_AUTO_TEST_CASE(valid) |
0
|
215 { |
9
|
216 std::string s{u8"AÉC"}; |
|
217 std::string r = unicode::tolower(s); |
0
|
218 |
9
|
219 BOOST_TEST(r == u8"aéc"); |
0
|
220 } |
|
221 |
4
|
222 BOOST_AUTO_TEST_CASE(invalid) |
0
|
223 { |
9
|
224 std::string s{"A" "\xFF""B"}; |
0
|
225 |
9
|
226 BOOST_REQUIRE_THROW(unicode::tolower(s), std::exception); |
0
|
227 } |
|
228 |
4
|
229 BOOST_AUTO_TEST_SUITE_END() |
|
230 |
0
|
231 /* |
2
|
232 * Checks functions |
0
|
233 * ------------------------------------------------------------------ |
|
234 */ |
|
235 |
4
|
236 BOOST_AUTO_TEST_SUITE(checks) |
|
237 |
|
238 BOOST_AUTO_TEST_CASE(isspace) |
0
|
239 { |
9
|
240 BOOST_TEST(unicode::isspace(' ')); |
|
241 BOOST_TEST(!unicode::isspace(/* é */ 233)); |
0
|
242 } |
|
243 |
4
|
244 BOOST_AUTO_TEST_CASE(isalpha) |
0
|
245 { |
9
|
246 BOOST_TEST(unicode::isalpha(U'é')); |
|
247 BOOST_TEST(!unicode::isalpha(U'€')); |
0
|
248 } |
|
249 |
4
|
250 BOOST_AUTO_TEST_CASE(isupper) |
0
|
251 { |
9
|
252 BOOST_TEST(!unicode::isupper('a')); |
|
253 BOOST_TEST(!unicode::isupper(U'é')); |
|
254 BOOST_TEST(unicode::isupper('A')); |
|
255 BOOST_TEST(unicode::isupper(U'É')); |
0
|
256 } |
|
257 |
4
|
258 BOOST_AUTO_TEST_CASE(islower) |
0
|
259 { |
9
|
260 BOOST_TEST(unicode::islower('a')); |
|
261 BOOST_TEST(unicode::islower(U'é')); |
|
262 BOOST_TEST(!unicode::islower('A')); |
|
263 BOOST_TEST(!unicode::islower(U'É')); |
0
|
264 } |
|
265 |
4
|
266 BOOST_AUTO_TEST_SUITE_END() |
|
267 |
0
|
268 /* |
|
269 * Miscellaneous |
|
270 * ------------------------------------------------------------------ |
|
271 */ |
|
272 |
4
|
273 BOOST_AUTO_TEST_SUITE(misc) |
|
274 |
|
275 BOOST_AUTO_TEST_CASE(nbytes_point) |
0
|
276 { |
9
|
277 BOOST_TEST(unicode::nbytes_point('a') == 1); |
|
278 BOOST_TEST(unicode::nbytes_point(U'é') == 2); |
|
279 BOOST_TEST(unicode::nbytes_point(U'€') == 3); |
|
280 BOOST_TEST(unicode::nbytes_point(U'𠀀') == 4); |
0
|
281 } |
|
282 |
4
|
283 BOOST_AUTO_TEST_CASE(nbytes_utf8) |
0
|
284 { |
9
|
285 std::string s1{u8"a"}; |
|
286 std::string s2{u8"é"}; |
|
287 std::string s3{u8"€"}; |
|
288 std::string s4{u8"𠀀"}; |
0
|
289 |
9
|
290 BOOST_TEST(unicode::nbytes_utf8(s1[0]) == 1); |
|
291 BOOST_TEST(unicode::nbytes_utf8(s2[0]) == 2); |
|
292 BOOST_TEST(unicode::nbytes_utf8(s3[0]) == 3); |
|
293 BOOST_TEST(unicode::nbytes_utf8(s4[0]) == 4); |
0
|
294 } |
|
295 |
4
|
296 BOOST_AUTO_TEST_CASE(for_each) |
0
|
297 { |
9
|
298 std::string s{u8"aé€𠀀"}; |
|
299 int current = 0; |
0
|
300 |
9
|
301 unicode::for_each(s, [&] (char32_t code) { |
|
302 if (current == 0) |
|
303 BOOST_TEST(code == U'a'); |
|
304 else if (current == 1) |
|
305 BOOST_TEST(code == U'é'); |
|
306 else if (current == 2) |
|
307 BOOST_TEST(code == U'€'); |
|
308 else if (current == 3) |
|
309 BOOST_TEST(code == U'𠀀'); |
0
|
310 |
9
|
311 current++; |
|
312 }); |
0
|
313 |
9
|
314 BOOST_TEST(current = 4); |
0
|
315 } |
|
316 |
4
|
317 BOOST_AUTO_TEST_CASE(for_each_invalid) |
0
|
318 { |
9
|
319 std::string s{"a" "\xFF" "b"}; |
0
|
320 |
9
|
321 BOOST_REQUIRE_THROW(unicode::for_each(s, [&] (char32_t) { }), std::exception); |
0
|
322 } |
|
323 |
4
|
324 BOOST_AUTO_TEST_SUITE_END() |
9
|
325 |
|
326 } // !namespace |
|
327 |