|
307
|
1 /* |
|
|
2 * main.cpp -- main test file for Utf8 |
|
|
3 * |
|
|
4 * Copyright (c) 2013, 2014 David Demelier <markand@malikania.fr> |
|
|
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 |
|
|
23 #include <gtest/gtest.h> |
|
|
24 |
|
|
25 #include <Utf8.h> |
|
|
26 |
|
|
27 using namespace testing; |
|
|
28 |
|
|
29 /* -------------------------------------------------------- |
|
|
30 * Conversion UTF32 -> UTF8 |
|
|
31 * -------------------------------------------------------- */ |
|
|
32 |
|
|
33 TEST(Conversion32to8, ascii) |
|
|
34 { |
|
|
35 try { |
|
|
36 std::u32string u32{'a', 'b', 'c'}; |
|
|
37 std::string s = Utf8::toutf8(u32); |
|
|
38 |
|
|
39 ASSERT_EQ("abc", s); |
|
|
40 } catch (const std::exception &ex) { |
|
|
41 FAIL() << ex.what(); |
|
|
42 } |
|
|
43 } |
|
|
44 |
|
|
45 TEST(Conversion32to8, valid) |
|
|
46 { |
|
|
47 try { |
|
|
48 std::u32string u32{'a', /* é */ 233, 'c'}; |
|
|
49 std::string s = Utf8::toutf8(u32); |
|
|
50 |
|
|
51 ASSERT_EQ("aéc", s); |
|
|
52 } catch (const std::exception &ex) { |
|
|
53 FAIL() << ex.what(); |
|
|
54 } |
|
|
55 } |
|
|
56 |
|
|
57 TEST(Conversion32to8, invalid) |
|
|
58 { |
|
|
59 try { |
|
|
60 std::u32string u32{'a', 0xFFFFFFFF, 'c'}; |
|
|
61 std::string s = Utf8::toutf8(u32); |
|
|
62 |
|
|
63 FAIL() << "expected a failure"; |
|
|
64 } catch (const std::exception &ex) { |
|
|
65 SUCCEED(); |
|
|
66 } |
|
|
67 } |
|
|
68 |
|
|
69 /* -------------------------------------------------------- |
|
|
70 * Conversion UTF8 -> UTF32 |
|
|
71 * -------------------------------------------------------- */ |
|
|
72 |
|
|
73 TEST(Conversion8to32, ascii) |
|
|
74 { |
|
|
75 try { |
|
|
76 std::string s{"abc"}; |
|
|
77 std::u32string expected{'a', 'b', 'c'}; |
|
|
78 std::u32string result = Utf8::toutf32(s); |
|
|
79 |
|
|
80 ASSERT_EQ(expected, result); |
|
|
81 } catch (const std::exception &ex) { |
|
|
82 FAIL() << ex.what(); |
|
|
83 } |
|
|
84 } |
|
|
85 |
|
|
86 TEST(Conversion8to32, valid) |
|
|
87 { |
|
|
88 try { |
|
|
89 std::string s{"aéc"}; |
|
|
90 std::u32string expected{'a', /* é */ 233, 'c'}; |
|
|
91 std::u32string result = Utf8::toutf32(s); |
|
|
92 |
|
|
93 ASSERT_EQ(expected, result); |
|
|
94 } catch (const std::exception &ex) { |
|
|
95 FAIL() << ex.what(); |
|
|
96 } |
|
|
97 } |
|
|
98 |
|
|
99 /* -------------------------------------------------------- |
|
|
100 * UTF32 to upper |
|
|
101 * -------------------------------------------------------- */ |
|
|
102 |
|
|
103 TEST(Toupper32, ascii) |
|
|
104 { |
|
|
105 try { |
|
|
106 std::u32string u32{'a', 'b', 'c'}; |
|
|
107 std::u32string expected{'A', 'B', 'C'}; |
|
|
108 std::u32string result = Utf8::toupper(u32); |
|
|
109 |
|
|
110 ASSERT_EQ(expected, result); |
|
|
111 } catch (const std::exception &ex) { |
|
|
112 FAIL() << ex.what(); |
|
|
113 } |
|
|
114 } |
|
|
115 |
|
|
116 TEST(Toupper32, valid) |
|
|
117 { |
|
|
118 try { |
|
|
119 std::u32string u32{/* ä */ 228, /* ç */ 231, /* ë */ 235}; |
|
|
120 std::u32string expected{/* Ä */ 196, /* Ç */ 199, /* Ë */ 203}; |
|
|
121 std::u32string result = Utf8::toupper(u32); |
|
|
122 |
|
|
123 ASSERT_EQ(expected, result); |
|
|
124 } catch (const std::exception &ex) { |
|
|
125 FAIL() << ex.what(); |
|
|
126 } |
|
|
127 } |
|
|
128 |
|
|
129 TEST(Toupper32, invalid) |
|
|
130 { |
|
|
131 try { |
|
|
132 std::u32string u32{'a', 0xFFFFFFFF, 'b'}; |
|
|
133 std::u32string expected{'A', 0xFFFFFFFF, 'B'}; |
|
|
134 std::u32string result = Utf8::toupper(u32); |
|
|
135 |
|
|
136 ASSERT_EQ(expected, result); |
|
|
137 } catch (const std::exception &ex) { |
|
|
138 FAIL() << ex.what(); |
|
|
139 } |
|
|
140 } |
|
|
141 |
|
|
142 /* -------------------------------------------------------- |
|
|
143 * UTF32 to lower |
|
|
144 * -------------------------------------------------------- */ |
|
|
145 |
|
|
146 TEST(Tolower32, ascii) |
|
|
147 { |
|
|
148 try { |
|
|
149 std::u32string u32{'A', 'B', 'C'}; |
|
|
150 std::u32string expected{'a', 'b', 'c'}; |
|
|
151 std::u32string result = Utf8::tolower(u32); |
|
|
152 |
|
|
153 ASSERT_EQ(expected, result); |
|
|
154 } catch (const std::exception &ex) { |
|
|
155 FAIL() << ex.what(); |
|
|
156 } |
|
|
157 } |
|
|
158 |
|
|
159 TEST(Tolower32, valid) |
|
|
160 { |
|
|
161 try { |
|
|
162 std::u32string u32{/* Ä */ 196, /* Ç */ 199, /* Ë */ 203}; |
|
|
163 std::u32string expected{/* ä */ 228, /* ç */ 231, /* ë */ 235}; |
|
|
164 std::u32string result = Utf8::tolower(u32); |
|
|
165 |
|
|
166 ASSERT_EQ(expected, result); |
|
|
167 } catch (const std::exception &ex) { |
|
|
168 FAIL() << ex.what(); |
|
|
169 } |
|
|
170 } |
|
|
171 |
|
|
172 TEST(Tolower32, invalid) |
|
|
173 { |
|
|
174 try { |
|
|
175 std::u32string u32{'A', 0xFFFFFFFF, 'B'}; |
|
|
176 std::u32string expected{'a', 0xFFFFFFFF, 'b'}; |
|
|
177 std::u32string result = Utf8::tolower(u32); |
|
|
178 |
|
|
179 ASSERT_EQ(expected, result); |
|
|
180 } catch (const std::exception &ex) { |
|
|
181 FAIL() << ex.what(); |
|
|
182 } |
|
|
183 } |
|
|
184 |
|
|
185 /* -------------------------------------------------------- |
|
|
186 * UTF8 to upper |
|
|
187 * -------------------------------------------------------- */ |
|
|
188 |
|
|
189 TEST(Toupper8, ascii) |
|
|
190 { |
|
|
191 try { |
|
|
192 std::string s{"abc"}; |
|
|
193 std::string r = Utf8::toupper(s); |
|
|
194 |
|
|
195 ASSERT_EQ("ABC", r); |
|
|
196 } catch (const std::exception &ex) { |
|
|
197 FAIL() << ex.what(); |
|
|
198 } |
|
|
199 } |
|
|
200 |
|
|
201 TEST(Toupper8, valid) |
|
|
202 { |
|
|
203 try { |
|
|
204 std::string s{"aéc"}; |
|
|
205 std::string r = Utf8::toupper(s); |
|
|
206 |
|
|
207 ASSERT_EQ("AÉC", r); |
|
|
208 } catch (const std::exception &ex) { |
|
|
209 FAIL() << ex.what(); |
|
|
210 } |
|
|
211 } |
|
|
212 |
|
|
213 TEST(Toupper8, invalid) |
|
|
214 { |
|
|
215 try { |
|
|
216 std::string s{"a" "\xFF""b"}; |
|
|
217 std::string r = Utf8::toupper(s); |
|
|
218 |
|
|
219 FAIL() << "expected a failure"; |
|
|
220 } catch (const std::exception &ex) { |
|
|
221 SUCCEED(); |
|
|
222 } |
|
|
223 } |
|
|
224 |
|
|
225 /* -------------------------------------------------------- |
|
|
226 * UTF8 to lower |
|
|
227 * -------------------------------------------------------- */ |
|
|
228 |
|
|
229 TEST(Tolower8, ascii) |
|
|
230 { |
|
|
231 try { |
|
|
232 std::string s{"ABC"}; |
|
|
233 std::string r = Utf8::tolower(s); |
|
|
234 |
|
|
235 ASSERT_EQ("abc", r); |
|
|
236 } catch (const std::exception &ex) { |
|
|
237 FAIL() << ex.what(); |
|
|
238 } |
|
|
239 } |
|
|
240 |
|
|
241 TEST(Tolower8, valid) |
|
|
242 { |
|
|
243 try { |
|
|
244 std::string s{"AÉC"}; |
|
|
245 std::string r = Utf8::tolower(s); |
|
|
246 |
|
|
247 ASSERT_EQ("aéc", r); |
|
|
248 } catch (const std::exception &ex) { |
|
|
249 FAIL() << ex.what(); |
|
|
250 } |
|
|
251 } |
|
|
252 |
|
|
253 TEST(Tolower8, invalid) |
|
|
254 { |
|
|
255 try { |
|
|
256 std::string s{"A" "\xFF""B"}; |
|
|
257 std::string r = Utf8::tolower(s); |
|
|
258 |
|
|
259 FAIL() << "expected a failure"; |
|
|
260 } catch (const std::exception &ex) { |
|
|
261 SUCCEED(); |
|
|
262 } |
|
|
263 } |
|
|
264 |
|
|
265 /* -------------------------------------------------------- |
|
|
266 * Check functions |
|
|
267 * -------------------------------------------------------- */ |
|
|
268 |
|
|
269 TEST(Check, isspace) |
|
|
270 { |
|
|
271 ASSERT_TRUE(Utf8::isspace(' ')); |
|
|
272 ASSERT_FALSE(Utf8::isspace(/* é */ 233)); |
|
|
273 } |
|
|
274 |
|
|
275 TEST(Check, isletter) |
|
|
276 { |
|
|
277 ASSERT_TRUE(Utf8::isletter(/* é */ 233)); |
|
|
278 ASSERT_FALSE(Utf8::isletter(/* € */ 8364)); |
|
|
279 } |
|
|
280 |
|
|
281 TEST(Check, isupper) |
|
|
282 { |
|
|
283 ASSERT_FALSE(Utf8::isupper('a')); |
|
|
284 ASSERT_FALSE(Utf8::isupper(/* é */ 233)); |
|
|
285 ASSERT_TRUE(Utf8::isupper('A')); |
|
|
286 ASSERT_TRUE(Utf8::isupper(/* É */ 201)); |
|
|
287 } |
|
|
288 |
|
|
289 TEST(Check, islower) |
|
|
290 { |
|
|
291 ASSERT_TRUE(Utf8::islower('a')); |
|
|
292 ASSERT_TRUE(Utf8::islower(/* é */ 233)); |
|
|
293 ASSERT_FALSE(Utf8::islower('A')); |
|
|
294 ASSERT_FALSE(Utf8::islower(/* É */ 201)); |
|
|
295 } |
|
|
296 |
|
|
297 /* -------------------------------------------------------- |
|
|
298 * Miscellaneous |
|
|
299 * -------------------------------------------------------- */ |
|
|
300 |
|
|
301 TEST(Misc, nbytesPoint) |
|
|
302 { |
|
|
303 ASSERT_EQ(1, Utf8::nbytesPoint('a')); |
|
|
304 ASSERT_EQ(2, Utf8::nbytesPoint(/* é */ 233)); |
|
|
305 ASSERT_EQ(3, Utf8::nbytesPoint(/* € */ 8364)); |
|
|
306 ASSERT_EQ(4, Utf8::nbytesPoint(/* 𠀀 */ 131072)); |
|
|
307 } |
|
|
308 |
|
|
309 TEST(Misc, nbytesUtf8) |
|
|
310 { |
|
|
311 std::string s1{"a"}; |
|
|
312 std::string s2{"é"}; |
|
|
313 std::string s3{"€"}; |
|
|
314 std::string s4{"𠀀"}; |
|
|
315 |
|
|
316 ASSERT_EQ(1, Utf8::nbytesUtf8(s1[0])); |
|
|
317 ASSERT_EQ(2, Utf8::nbytesUtf8(s2[0])); |
|
|
318 ASSERT_EQ(3, Utf8::nbytesUtf8(s3[0])); |
|
|
319 ASSERT_EQ(4, Utf8::nbytesUtf8(s4[0])); |
|
|
320 } |
|
|
321 |
|
|
322 int main(int argc, char **argv) |
|
|
323 { |
|
|
324 InitGoogleTest(&argc, argv); |
|
|
325 |
|
|
326 return RUN_ALL_TESTS(); |
|
|
327 } |
