Mercurial > libunicode
comparison test/main.cpp @ 9:d9309daa0d7b
Style
author | David Demelier <markand@malikania.fr> |
---|---|
date | Fri, 19 Oct 2018 13:31:36 +0200 |
parents | ebcc8c9c8831 |
children |
comparison
equal
deleted
inserted
replaced
8:e7a1a3c4f850 | 9:d9309daa0d7b |
---|---|
25 | 25 |
26 #include <unicode.hpp> | 26 #include <unicode.hpp> |
27 | 27 |
28 namespace { | 28 namespace { |
29 | 29 |
30 bool equals(const std::u32string& s1, const std::u32string& s2) | 30 auto equals(const std::u32string& s1, const std::u32string& s2) -> bool |
31 { | 31 { |
32 return s1 == s2; | 32 return s1 == s2; |
33 } | 33 } |
34 | |
35 /* | |
36 * Conversion UTF32 -> UTF8 | |
37 * ------------------------------------------------------------------ | |
38 */ | |
39 | |
40 BOOST_AUTO_TEST_SUITE(convert_32_to_8) | |
41 | |
42 BOOST_AUTO_TEST_CASE(ascii) | |
43 { | |
44 std::u32string u32{'a', 'b', 'c'}; | |
45 std::string s = unicode::to_utf8(u32); | |
46 | |
47 BOOST_TEST(s == "abc"); | |
48 } | |
49 | |
50 BOOST_AUTO_TEST_CASE(valid) | |
51 { | |
52 std::u32string u32{'a', U'é', 'c', U'𠀀'}; | |
53 std::string s = unicode::to_utf8(u32); | |
54 std::string expected = u8"aéc𠀀"; | |
55 | |
56 BOOST_TEST(s == expected); | |
57 } | |
58 | |
59 BOOST_AUTO_TEST_CASE(invalid) | |
60 { | |
61 std::u32string u32{'a', 0xFFFFFFFF, 'c'}; | |
62 | |
63 BOOST_REQUIRE_THROW(unicode::to_utf8(u32), std::exception); | |
64 } | |
65 | |
66 BOOST_AUTO_TEST_SUITE_END() | |
67 | |
68 /* | |
69 * Conversion UTF8 -> UTF32 | |
70 * ------------------------------------------------------------------ | |
71 */ | |
72 | |
73 BOOST_AUTO_TEST_SUITE(convert_8_to_32) | |
74 | |
75 BOOST_AUTO_TEST_CASE(ascii) | |
76 { | |
77 std::string s{"abc"}; | |
78 std::u32string expected{'a', 'b', 'c'}; | |
79 std::u32string result = unicode::to_utf32(s); | |
80 | |
81 BOOST_TEST(equals(result, expected)); | |
82 } | |
83 | |
84 BOOST_AUTO_TEST_CASE(valid) | |
85 { | |
86 std::string s{u8"aéc𠀀"}; | |
87 std::u32string expected{'a', U'é', 'c', U'𠀀'}; | |
88 std::u32string result = unicode::to_utf32(s); | |
89 | |
90 BOOST_TEST(equals(result, expected)); | |
91 } | |
92 | |
93 BOOST_AUTO_TEST_SUITE_END() | |
94 | |
95 /* | |
96 * UTF32 to upper | |
97 * ------------------------------------------------------------------ | |
98 */ | |
99 | |
100 BOOST_AUTO_TEST_SUITE(toupper_32) | |
101 | |
102 BOOST_AUTO_TEST_CASE(ascii) | |
103 { | |
104 std::u32string u32{'a', 'b', 'c'}; | |
105 std::u32string expected{'A', 'B', 'C'}; | |
106 std::u32string result = unicode::toupper(u32); | |
107 | |
108 BOOST_TEST(equals(result, expected)); | |
109 } | |
110 | |
111 BOOST_AUTO_TEST_CASE(valid) | |
112 { | |
113 std::u32string u32{U'ä', U'ç', U'ë'}; | |
114 std::u32string expected{U'Ä', U'Ç', U'Ë'}; | |
115 std::u32string result = unicode::toupper(u32); | |
116 | |
117 BOOST_TEST(equals(result, expected)); | |
118 } | |
119 | |
120 BOOST_AUTO_TEST_CASE(invalid) | |
121 { | |
122 std::u32string u32{'a', 0xFFFFFFFF, 'b'}; | |
123 std::u32string expected{'A', 0xFFFFFFFF, 'B'}; | |
124 std::u32string result = unicode::toupper(u32); | |
125 | |
126 BOOST_TEST(equals(result, expected)); | |
127 } | |
128 | |
129 BOOST_AUTO_TEST_SUITE_END() | |
130 | |
131 /* | |
132 * UTF32 to lower | |
133 * ------------------------------------------------------------------ | |
134 */ | |
135 | |
136 BOOST_AUTO_TEST_SUITE(tolower_32) | |
137 | |
138 BOOST_AUTO_TEST_CASE(ascii) | |
139 { | |
140 std::u32string u32{'A', 'B', 'C'}; | |
141 std::u32string expected{'a', 'b', 'c'}; | |
142 std::u32string result = unicode::tolower(u32); | |
143 | |
144 BOOST_TEST(equals(result, expected)); | |
145 } | |
146 | |
147 BOOST_AUTO_TEST_CASE(valid) | |
148 { | |
149 std::u32string u32{U'Ä', U'Ç', U'Ë'}; | |
150 std::u32string expected{U'ä', U'ç', U'ë'}; | |
151 std::u32string result = unicode::tolower(u32); | |
152 | |
153 BOOST_TEST(equals(result, expected)); | |
154 } | |
155 | |
156 BOOST_AUTO_TEST_CASE(invalid) | |
157 { | |
158 std::u32string u32{'A', 0xFFFFFFFF, 'B'}; | |
159 std::u32string expected{'a', 0xFFFFFFFF, 'b'}; | |
160 std::u32string result = unicode::tolower(u32); | |
161 | |
162 BOOST_TEST(equals(result, expected)); | |
163 } | |
164 | |
165 BOOST_AUTO_TEST_SUITE_END() | |
166 | |
167 /* | |
168 * UTF8 to upper | |
169 * ------------------------------------------------------------------ | |
170 */ | |
171 | |
172 BOOST_AUTO_TEST_SUITE(toupper_8) | |
173 | |
174 BOOST_AUTO_TEST_CASE(ascii) | |
175 { | |
176 std::string s{"abc"}; | |
177 std::string r = unicode::toupper(s); | |
178 | |
179 BOOST_TEST(r == "ABC"); | |
180 } | |
181 | |
182 BOOST_AUTO_TEST_CASE(valid) | |
183 { | |
184 std::string s{u8"aéc"}; | |
185 std::string r = unicode::toupper(s); | |
186 | |
187 BOOST_TEST(r == u8"AÉC"); | |
188 } | |
189 | |
190 BOOST_AUTO_TEST_CASE(invalid) | |
191 { | |
192 std::string s{"a" "\xFF""b"}; | |
193 | |
194 BOOST_REQUIRE_THROW(unicode::toupper(s), std::exception); | |
195 } | |
196 | |
197 BOOST_AUTO_TEST_SUITE_END() | |
198 | |
199 /* | |
200 * UTF8 to lower | |
201 * ------------------------------------------------------------------ | |
202 */ | |
203 | |
204 BOOST_AUTO_TEST_SUITE(tolower_8) | |
205 | |
206 BOOST_AUTO_TEST_CASE(ascii) | |
207 { | |
208 std::string s{"ABC"}; | |
209 std::string r = unicode::tolower(s); | |
210 | |
211 BOOST_TEST(r == "abc"); | |
212 } | |
213 | |
214 BOOST_AUTO_TEST_CASE(valid) | |
215 { | |
216 std::string s{u8"AÉC"}; | |
217 std::string r = unicode::tolower(s); | |
218 | |
219 BOOST_TEST(r == u8"aéc"); | |
220 } | |
221 | |
222 BOOST_AUTO_TEST_CASE(invalid) | |
223 { | |
224 std::string s{"A" "\xFF""B"}; | |
225 | |
226 BOOST_REQUIRE_THROW(unicode::tolower(s), std::exception); | |
227 } | |
228 | |
229 BOOST_AUTO_TEST_SUITE_END() | |
230 | |
231 /* | |
232 * Checks functions | |
233 * ------------------------------------------------------------------ | |
234 */ | |
235 | |
236 BOOST_AUTO_TEST_SUITE(checks) | |
237 | |
238 BOOST_AUTO_TEST_CASE(isspace) | |
239 { | |
240 BOOST_TEST(unicode::isspace(' ')); | |
241 BOOST_TEST(!unicode::isspace(/* é */ 233)); | |
242 } | |
243 | |
244 BOOST_AUTO_TEST_CASE(isalpha) | |
245 { | |
246 BOOST_TEST(unicode::isalpha(U'é')); | |
247 BOOST_TEST(!unicode::isalpha(U'€')); | |
248 } | |
249 | |
250 BOOST_AUTO_TEST_CASE(isupper) | |
251 { | |
252 BOOST_TEST(!unicode::isupper('a')); | |
253 BOOST_TEST(!unicode::isupper(U'é')); | |
254 BOOST_TEST(unicode::isupper('A')); | |
255 BOOST_TEST(unicode::isupper(U'É')); | |
256 } | |
257 | |
258 BOOST_AUTO_TEST_CASE(islower) | |
259 { | |
260 BOOST_TEST(unicode::islower('a')); | |
261 BOOST_TEST(unicode::islower(U'é')); | |
262 BOOST_TEST(!unicode::islower('A')); | |
263 BOOST_TEST(!unicode::islower(U'É')); | |
264 } | |
265 | |
266 BOOST_AUTO_TEST_SUITE_END() | |
267 | |
268 /* | |
269 * Miscellaneous | |
270 * ------------------------------------------------------------------ | |
271 */ | |
272 | |
273 BOOST_AUTO_TEST_SUITE(misc) | |
274 | |
275 BOOST_AUTO_TEST_CASE(nbytes_point) | |
276 { | |
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); | |
281 } | |
282 | |
283 BOOST_AUTO_TEST_CASE(nbytes_utf8) | |
284 { | |
285 std::string s1{u8"a"}; | |
286 std::string s2{u8"é"}; | |
287 std::string s3{u8"€"}; | |
288 std::string s4{u8"𠀀"}; | |
289 | |
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); | |
294 } | |
295 | |
296 BOOST_AUTO_TEST_CASE(for_each) | |
297 { | |
298 std::string s{u8"aé€𠀀"}; | |
299 int current = 0; | |
300 | |
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'𠀀'); | |
310 | |
311 current++; | |
312 }); | |
313 | |
314 BOOST_TEST(current = 4); | |
315 } | |
316 | |
317 BOOST_AUTO_TEST_CASE(for_each_invalid) | |
318 { | |
319 std::string s{"a" "\xFF" "b"}; | |
320 | |
321 BOOST_REQUIRE_THROW(unicode::for_each(s, [&] (char32_t) { }), std::exception); | |
322 } | |
323 | |
324 BOOST_AUTO_TEST_SUITE_END() | |
34 | 325 |
35 } // !namespace | 326 } // !namespace |
36 | 327 |
37 /* | |
38 * Conversion UTF32 -> UTF8 | |
39 * ------------------------------------------------------------------ | |
40 */ | |
41 | |
42 BOOST_AUTO_TEST_SUITE(convert_32_to_8) | |
43 | |
44 BOOST_AUTO_TEST_CASE(ascii) | |
45 { | |
46 std::u32string u32{'a', 'b', 'c'}; | |
47 std::string s = unicode::to_utf8(u32); | |
48 | |
49 BOOST_TEST(s == "abc"); | |
50 } | |
51 | |
52 BOOST_AUTO_TEST_CASE(valid) | |
53 { | |
54 std::u32string u32{'a', U'é', 'c', U'𠀀'}; | |
55 std::string s = unicode::to_utf8(u32); | |
56 std::string expected = u8"aéc𠀀"; | |
57 | |
58 BOOST_TEST(s == expected); | |
59 } | |
60 | |
61 BOOST_AUTO_TEST_CASE(invalid) | |
62 { | |
63 std::u32string u32{'a', 0xFFFFFFFF, 'c'}; | |
64 | |
65 BOOST_REQUIRE_THROW(unicode::to_utf8(u32), std::exception); | |
66 } | |
67 | |
68 BOOST_AUTO_TEST_SUITE_END() | |
69 | |
70 /* | |
71 * Conversion UTF8 -> UTF32 | |
72 * ------------------------------------------------------------------ | |
73 */ | |
74 | |
75 BOOST_AUTO_TEST_SUITE(convert_8_to_32) | |
76 | |
77 BOOST_AUTO_TEST_CASE(ascii) | |
78 { | |
79 std::string s{"abc"}; | |
80 std::u32string expected{'a', 'b', 'c'}; | |
81 std::u32string result = unicode::to_utf32(s); | |
82 | |
83 BOOST_TEST(equals(result, expected)); | |
84 } | |
85 | |
86 BOOST_AUTO_TEST_CASE(valid) | |
87 { | |
88 std::string s{u8"aéc𠀀"}; | |
89 std::u32string expected{'a', U'é', 'c', U'𠀀'}; | |
90 std::u32string result = unicode::to_utf32(s); | |
91 | |
92 BOOST_TEST(equals(result, expected)); | |
93 } | |
94 | |
95 BOOST_AUTO_TEST_SUITE_END() | |
96 | |
97 /* | |
98 * UTF32 to upper | |
99 * ------------------------------------------------------------------ | |
100 */ | |
101 | |
102 BOOST_AUTO_TEST_SUITE(toupper_32) | |
103 | |
104 BOOST_AUTO_TEST_CASE(ascii) | |
105 { | |
106 std::u32string u32{'a', 'b', 'c'}; | |
107 std::u32string expected{'A', 'B', 'C'}; | |
108 std::u32string result = unicode::toupper(u32); | |
109 | |
110 BOOST_TEST(equals(result, expected)); | |
111 } | |
112 | |
113 BOOST_AUTO_TEST_CASE(valid) | |
114 { | |
115 std::u32string u32{U'ä', U'ç', U'ë'}; | |
116 std::u32string expected{U'Ä', U'Ç', U'Ë'}; | |
117 std::u32string result = unicode::toupper(u32); | |
118 | |
119 BOOST_TEST(equals(result, expected)); | |
120 } | |
121 | |
122 BOOST_AUTO_TEST_CASE(invalid) | |
123 { | |
124 std::u32string u32{'a', 0xFFFFFFFF, 'b'}; | |
125 std::u32string expected{'A', 0xFFFFFFFF, 'B'}; | |
126 std::u32string result = unicode::toupper(u32); | |
127 | |
128 BOOST_TEST(equals(result, expected)); | |
129 } | |
130 | |
131 BOOST_AUTO_TEST_SUITE_END() | |
132 | |
133 /* | |
134 * UTF32 to lower | |
135 * ------------------------------------------------------------------ | |
136 */ | |
137 | |
138 BOOST_AUTO_TEST_SUITE(tolower_32) | |
139 | |
140 BOOST_AUTO_TEST_CASE(ascii) | |
141 { | |
142 std::u32string u32{'A', 'B', 'C'}; | |
143 std::u32string expected{'a', 'b', 'c'}; | |
144 std::u32string result = unicode::tolower(u32); | |
145 | |
146 BOOST_TEST(equals(result, expected)); | |
147 } | |
148 | |
149 BOOST_AUTO_TEST_CASE(valid) | |
150 { | |
151 std::u32string u32{U'Ä', U'Ç', U'Ë'}; | |
152 std::u32string expected{U'ä', U'ç', U'ë'}; | |
153 std::u32string result = unicode::tolower(u32); | |
154 | |
155 BOOST_TEST(equals(result, expected)); | |
156 } | |
157 | |
158 BOOST_AUTO_TEST_CASE(invalid) | |
159 { | |
160 std::u32string u32{'A', 0xFFFFFFFF, 'B'}; | |
161 std::u32string expected{'a', 0xFFFFFFFF, 'b'}; | |
162 std::u32string result = unicode::tolower(u32); | |
163 | |
164 BOOST_TEST(equals(result, expected)); | |
165 } | |
166 | |
167 BOOST_AUTO_TEST_SUITE_END() | |
168 | |
169 /* | |
170 * UTF8 to upper | |
171 * ------------------------------------------------------------------ | |
172 */ | |
173 | |
174 BOOST_AUTO_TEST_SUITE(toupper_8) | |
175 | |
176 BOOST_AUTO_TEST_CASE(ascii) | |
177 { | |
178 std::string s{"abc"}; | |
179 std::string r = unicode::toupper(s); | |
180 | |
181 BOOST_TEST(r == "ABC"); | |
182 } | |
183 | |
184 BOOST_AUTO_TEST_CASE(valid) | |
185 { | |
186 std::string s{u8"aéc"}; | |
187 std::string r = unicode::toupper(s); | |
188 | |
189 BOOST_TEST(r == u8"AÉC"); | |
190 } | |
191 | |
192 BOOST_AUTO_TEST_CASE(invalid) | |
193 { | |
194 std::string s{"a" "\xFF""b"}; | |
195 | |
196 BOOST_REQUIRE_THROW(unicode::toupper(s), std::exception); | |
197 } | |
198 | |
199 BOOST_AUTO_TEST_SUITE_END() | |
200 | |
201 /* | |
202 * UTF8 to lower | |
203 * ------------------------------------------------------------------ | |
204 */ | |
205 | |
206 BOOST_AUTO_TEST_SUITE(tolower_8) | |
207 | |
208 BOOST_AUTO_TEST_CASE(ascii) | |
209 { | |
210 std::string s{"ABC"}; | |
211 std::string r = unicode::tolower(s); | |
212 | |
213 BOOST_TEST(r == "abc"); | |
214 } | |
215 | |
216 BOOST_AUTO_TEST_CASE(valid) | |
217 { | |
218 std::string s{u8"AÉC"}; | |
219 std::string r = unicode::tolower(s); | |
220 | |
221 BOOST_TEST(r == u8"aéc"); | |
222 } | |
223 | |
224 BOOST_AUTO_TEST_CASE(invalid) | |
225 { | |
226 std::string s{"A" "\xFF""B"}; | |
227 | |
228 BOOST_REQUIRE_THROW(unicode::tolower(s), std::exception); | |
229 } | |
230 | |
231 BOOST_AUTO_TEST_SUITE_END() | |
232 | |
233 /* | |
234 * Checks functions | |
235 * ------------------------------------------------------------------ | |
236 */ | |
237 | |
238 BOOST_AUTO_TEST_SUITE(checks) | |
239 | |
240 BOOST_AUTO_TEST_CASE(isspace) | |
241 { | |
242 BOOST_TEST(unicode::isspace(' ')); | |
243 BOOST_TEST(!unicode::isspace(/* é */ 233)); | |
244 } | |
245 | |
246 BOOST_AUTO_TEST_CASE(isalpha) | |
247 { | |
248 BOOST_TEST(unicode::isalpha(U'é')); | |
249 BOOST_TEST(!unicode::isalpha(U'€')); | |
250 } | |
251 | |
252 BOOST_AUTO_TEST_CASE(isupper) | |
253 { | |
254 BOOST_TEST(!unicode::isupper('a')); | |
255 BOOST_TEST(!unicode::isupper(U'é')); | |
256 BOOST_TEST(unicode::isupper('A')); | |
257 BOOST_TEST(unicode::isupper(U'É')); | |
258 } | |
259 | |
260 BOOST_AUTO_TEST_CASE(islower) | |
261 { | |
262 BOOST_TEST(unicode::islower('a')); | |
263 BOOST_TEST(unicode::islower(U'é')); | |
264 BOOST_TEST(!unicode::islower('A')); | |
265 BOOST_TEST(!unicode::islower(U'É')); | |
266 } | |
267 | |
268 BOOST_AUTO_TEST_SUITE_END() | |
269 | |
270 /* | |
271 * Miscellaneous | |
272 * ------------------------------------------------------------------ | |
273 */ | |
274 | |
275 BOOST_AUTO_TEST_SUITE(misc) | |
276 | |
277 BOOST_AUTO_TEST_CASE(nbytes_point) | |
278 { | |
279 BOOST_TEST(unicode::nbytes_point('a') == 1); | |
280 BOOST_TEST(unicode::nbytes_point(U'é') == 2); | |
281 BOOST_TEST(unicode::nbytes_point(U'€') == 3); | |
282 BOOST_TEST(unicode::nbytes_point(U'𠀀') == 4); | |
283 } | |
284 | |
285 BOOST_AUTO_TEST_CASE(nbytes_utf8) | |
286 { | |
287 std::string s1{u8"a"}; | |
288 std::string s2{u8"é"}; | |
289 std::string s3{u8"€"}; | |
290 std::string s4{u8"𠀀"}; | |
291 | |
292 BOOST_TEST(unicode::nbytes_utf8(s1[0]) == 1); | |
293 BOOST_TEST(unicode::nbytes_utf8(s2[0]) == 2); | |
294 BOOST_TEST(unicode::nbytes_utf8(s3[0]) == 3); | |
295 BOOST_TEST(unicode::nbytes_utf8(s4[0]) == 4); | |
296 } | |
297 | |
298 BOOST_AUTO_TEST_CASE(for_each) | |
299 { | |
300 std::string s{u8"aé€𠀀"}; | |
301 int current = 0; | |
302 | |
303 unicode::for_each(s, [&] (char32_t code) { | |
304 if (current == 0) | |
305 BOOST_TEST(code == U'a'); | |
306 else if (current == 1) | |
307 BOOST_TEST(code == U'é'); | |
308 else if (current == 2) | |
309 BOOST_TEST(code == U'€'); | |
310 else if (current == 3) | |
311 BOOST_TEST(code == U'𠀀'); | |
312 | |
313 current++; | |
314 }); | |
315 | |
316 BOOST_TEST(current = 4); | |
317 } | |
318 | |
319 BOOST_AUTO_TEST_CASE(for_each_invalid) | |
320 { | |
321 std::string s{"a" "\xFF" "b"}; | |
322 | |
323 BOOST_REQUIRE_THROW(unicode::for_each(s, [&] (char32_t) { }), std::exception); | |
324 } | |
325 | |
326 BOOST_AUTO_TEST_SUITE_END() |