Branch data Line data Source code
1 : : /* Unit tests for utilities
2 : : * Copyright (C) 2010 Red Hat, Inc.
3 : : * Copyright (C) 2011 Google, Inc.
4 : : *
5 : : * SPDX-License-Identifier: LicenseRef-old-glib-tests
6 : : *
7 : : * This work is provided "as is"; redistribution and modification
8 : : * in whole or in part, in any medium, physical or electronic is
9 : : * permitted without restriction.
10 : : *
11 : : * This work is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14 : : *
15 : : * In no event shall the authors or contributors be liable for any
16 : : * direct, indirect, incidental, special, exemplary, or consequential
17 : : * damages (including, but not limited to, procurement of substitute
18 : : * goods or services; loss of use, data, or profits; or business
19 : : * interruption) however caused and on any theory of liability, whether
20 : : * in contract, strict liability, or tort (including negligence or
21 : : * otherwise) arising in any way out of the use of this software, even
22 : : * if advised of the possibility of such damage.
23 : : *
24 : : * Author: Matthias Clasen, Behdad Esfahbod
25 : : */
26 : :
27 : : /* We are testing some deprecated APIs here */
28 : : #ifndef GLIB_DISABLE_DEPRECATION_WARNINGS
29 : : #define GLIB_DISABLE_DEPRECATION_WARNINGS
30 : : #endif
31 : :
32 : : #include <locale.h>
33 : : #include <stdio.h>
34 : :
35 : : #include "glib.h"
36 : :
37 : : #include "glib/gunidecomp.h"
38 : :
39 : : #ifdef G_OS_WIN32
40 : : #include <windows.h>
41 : : #endif
42 : :
43 : : static void
44 : 6 : save_and_clear_env (const char *name,
45 : : char **save)
46 : : {
47 : 6 : *save = g_strdup (g_getenv (name));
48 : 6 : g_unsetenv (name);
49 : 6 : }
50 : :
51 : : /* Test that g_unichar_validate() returns the correct value for various
52 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
53 : : static void
54 : 1 : test_unichar_validate (void)
55 : : {
56 : 1 : g_assert_true (g_unichar_validate ('j'));
57 : 1 : g_assert_true (g_unichar_validate (8356));
58 : 1 : g_assert_true (g_unichar_validate (8356));
59 : 1 : g_assert_true (g_unichar_validate (0xFDD1));
60 : 1 : g_assert_true (g_unichar_validate (917760));
61 : 1 : g_assert_false (g_unichar_validate (0x110000));
62 : 1 : }
63 : :
64 : : /* Test that g_unichar_type() returns the correct value for various
65 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
66 : : static void
67 : 1 : test_unichar_character_type (void)
68 : : {
69 : : guint i;
70 : : struct {
71 : : GUnicodeType type;
72 : : gunichar c;
73 : 1 : } examples[] = {
74 : : { G_UNICODE_CONTROL, 0x000D },
75 : : { G_UNICODE_FORMAT, 0x200E },
76 : : /* G_UNICODE_UNASSIGNED */
77 : : { G_UNICODE_PRIVATE_USE, 0xE000 },
78 : : { G_UNICODE_SURROGATE, 0xD800 },
79 : : { G_UNICODE_LOWERCASE_LETTER, 0x0061 },
80 : : { G_UNICODE_MODIFIER_LETTER, 0x02B0 },
81 : : { G_UNICODE_OTHER_LETTER, 0x3400 },
82 : : { G_UNICODE_TITLECASE_LETTER, 0x01C5 },
83 : : { G_UNICODE_UPPERCASE_LETTER, 0xFF21 },
84 : : { G_UNICODE_SPACING_MARK, 0x0903 },
85 : : { G_UNICODE_ENCLOSING_MARK, 0x20DD },
86 : : { G_UNICODE_NON_SPACING_MARK, 0xA806 },
87 : : { G_UNICODE_DECIMAL_NUMBER, 0xFF10 },
88 : : { G_UNICODE_LETTER_NUMBER, 0x16EE },
89 : : { G_UNICODE_OTHER_NUMBER, 0x17F0 },
90 : : { G_UNICODE_CONNECT_PUNCTUATION, 0x005F },
91 : : { G_UNICODE_DASH_PUNCTUATION, 0x058A },
92 : : { G_UNICODE_CLOSE_PUNCTUATION, 0x0F3B },
93 : : { G_UNICODE_FINAL_PUNCTUATION, 0x2019 },
94 : : { G_UNICODE_INITIAL_PUNCTUATION, 0x2018 },
95 : : { G_UNICODE_OTHER_PUNCTUATION, 0x2016 },
96 : : { G_UNICODE_OPEN_PUNCTUATION, 0x0F3A },
97 : : { G_UNICODE_CURRENCY_SYMBOL, 0x20A0 },
98 : : { G_UNICODE_MODIFIER_SYMBOL, 0x309B },
99 : : { G_UNICODE_MATH_SYMBOL, 0xFB29 },
100 : : { G_UNICODE_OTHER_SYMBOL, 0x00A6 },
101 : : { G_UNICODE_LINE_SEPARATOR, 0x2028 },
102 : : { G_UNICODE_PARAGRAPH_SEPARATOR, 0x2029 },
103 : : { G_UNICODE_SPACE_SEPARATOR, 0x202F },
104 : : };
105 : :
106 [ + + ]: 30 : for (i = 0; i < G_N_ELEMENTS (examples); i++)
107 : : {
108 : 29 : g_assert_cmpint (g_unichar_type (examples[i].c), ==, examples[i].type);
109 : : }
110 : :
111 : : /*** Testing TYPE() border cases ***/
112 : 1 : g_assert_cmpint (g_unichar_type (0x3FF5), ==, 0x07);
113 : : /* U+FFEFF Plane 15 Private Use */
114 : 1 : g_assert_cmpint (g_unichar_type (0xFFEFF), ==, 0x03);
115 : : /* U+E0001 Language Tag */
116 : 1 : g_assert_cmpint (g_unichar_type (0xE0001), ==, 0x01);
117 : 1 : g_assert_cmpint (g_unichar_type (G_UNICODE_LAST_CHAR), ==, 0x02);
118 : 1 : g_assert_cmpint (g_unichar_type (G_UNICODE_LAST_CHAR + 1), ==, 0x02);
119 : 1 : g_assert_cmpint (g_unichar_type (G_UNICODE_LAST_CHAR_PART1), ==, 0x02);
120 : 1 : g_assert_cmpint (g_unichar_type (G_UNICODE_LAST_CHAR_PART1 + 1), ==, 0x02);
121 : 1 : }
122 : :
123 : : /* Test that g_unichar_break_type() returns the correct value for various
124 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
125 : : static void
126 : 1 : test_unichar_break_type (void)
127 : : {
128 : : guint i;
129 : : struct {
130 : : GUnicodeBreakType type;
131 : : gunichar c;
132 : 1 : } examples[] = {
133 : : { G_UNICODE_BREAK_MANDATORY, 0x2028 },
134 : : { G_UNICODE_BREAK_CARRIAGE_RETURN, 0x000D },
135 : : { G_UNICODE_BREAK_LINE_FEED, 0x000A },
136 : : { G_UNICODE_BREAK_COMBINING_MARK, 0x0300 },
137 : : { G_UNICODE_BREAK_SURROGATE, 0xD800 },
138 : : { G_UNICODE_BREAK_ZERO_WIDTH_SPACE, 0x200B },
139 : : { G_UNICODE_BREAK_INSEPARABLE, 0x2024 },
140 : : { G_UNICODE_BREAK_NON_BREAKING_GLUE, 0x00A0 },
141 : : { G_UNICODE_BREAK_CONTINGENT, 0xFFFC },
142 : : { G_UNICODE_BREAK_SPACE, 0x0020 },
143 : : { G_UNICODE_BREAK_AFTER, 0x05BE },
144 : : { G_UNICODE_BREAK_BEFORE, 0x02C8 },
145 : : { G_UNICODE_BREAK_BEFORE_AND_AFTER, 0x2014 },
146 : : { G_UNICODE_BREAK_HYPHEN, 0x002D },
147 : : { G_UNICODE_BREAK_NON_STARTER, 0x17D6 },
148 : : { G_UNICODE_BREAK_OPEN_PUNCTUATION, 0x0028 },
149 : : { G_UNICODE_BREAK_CLOSE_PARENTHESIS, 0x0029 },
150 : : { G_UNICODE_BREAK_CLOSE_PUNCTUATION, 0x007D },
151 : : { G_UNICODE_BREAK_QUOTATION, 0x0022 },
152 : : { G_UNICODE_BREAK_EXCLAMATION, 0x0021 },
153 : : { G_UNICODE_BREAK_IDEOGRAPHIC, 0x2E80 },
154 : : { G_UNICODE_BREAK_NUMERIC, 0x0030 },
155 : : { G_UNICODE_BREAK_INFIX_SEPARATOR, 0x002C },
156 : : { G_UNICODE_BREAK_SYMBOL, 0x002F },
157 : : { G_UNICODE_BREAK_ALPHABETIC, 0x0023 },
158 : : { G_UNICODE_BREAK_PREFIX, 0x0024 },
159 : : { G_UNICODE_BREAK_POSTFIX, 0x0025 },
160 : : { G_UNICODE_BREAK_COMPLEX_CONTEXT, 0x0E01 },
161 : : { G_UNICODE_BREAK_AMBIGUOUS, 0x00F7 },
162 : : { G_UNICODE_BREAK_UNKNOWN, 0xE000 },
163 : : { G_UNICODE_BREAK_NEXT_LINE, 0x0085 },
164 : : { G_UNICODE_BREAK_WORD_JOINER, 0x2060 },
165 : : { G_UNICODE_BREAK_HANGUL_L_JAMO, 0x1100 },
166 : : { G_UNICODE_BREAK_HANGUL_V_JAMO, 0x1160 },
167 : : { G_UNICODE_BREAK_HANGUL_T_JAMO, 0x11A8 },
168 : : { G_UNICODE_BREAK_HANGUL_LV_SYLLABLE, 0xAC00 },
169 : : { G_UNICODE_BREAK_HANGUL_LVT_SYLLABLE, 0xAC01 },
170 : : { G_UNICODE_BREAK_CONDITIONAL_JAPANESE_STARTER, 0x3041 },
171 : : { G_UNICODE_BREAK_HEBREW_LETTER, 0x05D0 },
172 : : { G_UNICODE_BREAK_REGIONAL_INDICATOR, 0x1F1F6 },
173 : : { G_UNICODE_BREAK_EMOJI_BASE, 0x1F466 },
174 : : { G_UNICODE_BREAK_EMOJI_MODIFIER, 0x1F3FB },
175 : : { G_UNICODE_BREAK_ZERO_WIDTH_JOINER, 0x200D },
176 : : { G_UNICODE_BREAK_AKSARA, 0x1B45 },
177 : : { G_UNICODE_BREAK_AKSARA_PRE_BASE, 0x1193F },
178 : : { G_UNICODE_BREAK_AKSARA_START, 0x11F50 },
179 : : { G_UNICODE_BREAK_VIRAMA_FINAL, 0x1BF3 },
180 : : { G_UNICODE_BREAK_VIRAMA, 0xA9C0 },
181 : : };
182 : :
183 [ + + ]: 49 : for (i = 0; i < G_N_ELEMENTS (examples); i++)
184 : : {
185 : 48 : g_assert_cmpint (g_unichar_break_type (examples[i].c), ==, examples[i].type);
186 : : }
187 : 1 : }
188 : :
189 : : /* Test that g_unichar_get_script() returns the correct value for various
190 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
191 : : static void
192 : 1 : test_unichar_script (void)
193 : : {
194 : : guint i;
195 : : struct {
196 : : GUnicodeScript script;
197 : : gunichar c;
198 : 1 : } examples[] = {
199 : : { G_UNICODE_SCRIPT_COMMON, 0x002A },
200 : : { G_UNICODE_SCRIPT_INHERITED, 0x1CED },
201 : : { G_UNICODE_SCRIPT_INHERITED, 0x0670 },
202 : : { G_UNICODE_SCRIPT_ARABIC, 0x060D },
203 : : { G_UNICODE_SCRIPT_ARMENIAN, 0x0559 },
204 : : { G_UNICODE_SCRIPT_BENGALI, 0x09CD },
205 : : { G_UNICODE_SCRIPT_BOPOMOFO, 0x31B6 },
206 : : { G_UNICODE_SCRIPT_CHEROKEE, 0x13A2 },
207 : : { G_UNICODE_SCRIPT_COPTIC, 0x2CFD },
208 : : { G_UNICODE_SCRIPT_CYRILLIC, 0x0482 },
209 : : { G_UNICODE_SCRIPT_DESERET, 0x10401 },
210 : : { G_UNICODE_SCRIPT_DEVANAGARI, 0x094D },
211 : : { G_UNICODE_SCRIPT_ETHIOPIC, 0x1258 },
212 : : { G_UNICODE_SCRIPT_GEORGIAN, 0x10FC },
213 : : { G_UNICODE_SCRIPT_GOTHIC, 0x10341 },
214 : : { G_UNICODE_SCRIPT_GREEK, 0x0375 },
215 : : { G_UNICODE_SCRIPT_GUJARATI, 0x0A83 },
216 : : { G_UNICODE_SCRIPT_GURMUKHI, 0x0A3C },
217 : : { G_UNICODE_SCRIPT_HAN, 0x3005 },
218 : : { G_UNICODE_SCRIPT_HANGUL, 0x1100 },
219 : : { G_UNICODE_SCRIPT_HEBREW, 0x05BF },
220 : : { G_UNICODE_SCRIPT_HIRAGANA, 0x309F },
221 : : { G_UNICODE_SCRIPT_KANNADA, 0x0CBC },
222 : : { G_UNICODE_SCRIPT_KATAKANA, 0x30FF },
223 : : { G_UNICODE_SCRIPT_KHMER, 0x17DD },
224 : : { G_UNICODE_SCRIPT_LAO, 0x0EDD },
225 : : { G_UNICODE_SCRIPT_LATIN, 0x0061 },
226 : : { G_UNICODE_SCRIPT_MALAYALAM, 0x0D3D },
227 : : { G_UNICODE_SCRIPT_MONGOLIAN, 0x1843 },
228 : : { G_UNICODE_SCRIPT_MYANMAR, 0x1031 },
229 : : { G_UNICODE_SCRIPT_OGHAM, 0x169C },
230 : : { G_UNICODE_SCRIPT_OLD_ITALIC, 0x10322 },
231 : : { G_UNICODE_SCRIPT_ORIYA, 0x0B3C },
232 : : { G_UNICODE_SCRIPT_RUNIC, 0x16EF },
233 : : { G_UNICODE_SCRIPT_SINHALA, 0x0DBD },
234 : : { G_UNICODE_SCRIPT_SYRIAC, 0x0711 },
235 : : { G_UNICODE_SCRIPT_TAMIL, 0x0B82 },
236 : : { G_UNICODE_SCRIPT_TELUGU, 0x0C03 },
237 : : { G_UNICODE_SCRIPT_THAANA, 0x07B1 },
238 : : { G_UNICODE_SCRIPT_THAI, 0x0E31 },
239 : : { G_UNICODE_SCRIPT_TIBETAN, 0x0FD4 },
240 : : { G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, 0x1400 },
241 : : { G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, 0x1401 },
242 : : { G_UNICODE_SCRIPT_YI, 0xA015 },
243 : : { G_UNICODE_SCRIPT_TAGALOG, 0x1700 },
244 : : { G_UNICODE_SCRIPT_HANUNOO, 0x1720 },
245 : : { G_UNICODE_SCRIPT_BUHID, 0x1740 },
246 : : { G_UNICODE_SCRIPT_TAGBANWA, 0x1760 },
247 : : { G_UNICODE_SCRIPT_BRAILLE, 0x2800 },
248 : : { G_UNICODE_SCRIPT_CYPRIOT, 0x10808 },
249 : : { G_UNICODE_SCRIPT_LIMBU, 0x1932 },
250 : : { G_UNICODE_SCRIPT_OSMANYA, 0x10480 },
251 : : { G_UNICODE_SCRIPT_SHAVIAN, 0x10450 },
252 : : { G_UNICODE_SCRIPT_LINEAR_B, 0x10000 },
253 : : { G_UNICODE_SCRIPT_TAI_LE, 0x1950 },
254 : : { G_UNICODE_SCRIPT_UGARITIC, 0x1039F },
255 : : { G_UNICODE_SCRIPT_NEW_TAI_LUE, 0x1980 },
256 : : { G_UNICODE_SCRIPT_BUGINESE, 0x1A1F },
257 : : { G_UNICODE_SCRIPT_GLAGOLITIC, 0x2C00 },
258 : : { G_UNICODE_SCRIPT_TIFINAGH, 0x2D6F },
259 : : { G_UNICODE_SCRIPT_SYLOTI_NAGRI, 0xA800 },
260 : : { G_UNICODE_SCRIPT_OLD_PERSIAN, 0x103D0 },
261 : : { G_UNICODE_SCRIPT_KHAROSHTHI, 0x10A3F },
262 : : { G_UNICODE_SCRIPT_UNKNOWN, 0x1111111 },
263 : : { G_UNICODE_SCRIPT_BALINESE, 0x1B04 },
264 : : { G_UNICODE_SCRIPT_CUNEIFORM, 0x12000 },
265 : : { G_UNICODE_SCRIPT_PHOENICIAN, 0x10900 },
266 : : { G_UNICODE_SCRIPT_PHAGS_PA, 0xA840 },
267 : : { G_UNICODE_SCRIPT_NKO, 0x07C0 },
268 : : { G_UNICODE_SCRIPT_KAYAH_LI, 0xA900 },
269 : : { G_UNICODE_SCRIPT_LEPCHA, 0x1C00 },
270 : : { G_UNICODE_SCRIPT_REJANG, 0xA930 },
271 : : { G_UNICODE_SCRIPT_SUNDANESE, 0x1B80 },
272 : : { G_UNICODE_SCRIPT_SAURASHTRA, 0xA880 },
273 : : { G_UNICODE_SCRIPT_CHAM, 0xAA00 },
274 : : { G_UNICODE_SCRIPT_OL_CHIKI, 0x1C50 },
275 : : { G_UNICODE_SCRIPT_VAI, 0xA500 },
276 : : { G_UNICODE_SCRIPT_CARIAN, 0x102A0 },
277 : : { G_UNICODE_SCRIPT_LYCIAN, 0x10280 },
278 : : { G_UNICODE_SCRIPT_LYDIAN, 0x1093F },
279 : : { G_UNICODE_SCRIPT_AVESTAN, 0x10B00 },
280 : : { G_UNICODE_SCRIPT_BAMUM, 0xA6A0 },
281 : : { G_UNICODE_SCRIPT_EGYPTIAN_HIEROGLYPHS, 0x13000 },
282 : : { G_UNICODE_SCRIPT_IMPERIAL_ARAMAIC, 0x10840 },
283 : : { G_UNICODE_SCRIPT_INSCRIPTIONAL_PAHLAVI, 0x10B60 },
284 : : { G_UNICODE_SCRIPT_INSCRIPTIONAL_PARTHIAN, 0x10B40 },
285 : : { G_UNICODE_SCRIPT_JAVANESE, 0xA980 },
286 : : { G_UNICODE_SCRIPT_KAITHI, 0x11082 },
287 : : { G_UNICODE_SCRIPT_LISU, 0xA4D0 },
288 : : { G_UNICODE_SCRIPT_MEETEI_MAYEK, 0xABE5 },
289 : : { G_UNICODE_SCRIPT_OLD_SOUTH_ARABIAN, 0x10A60 },
290 : : { G_UNICODE_SCRIPT_OLD_TURKIC, 0x10C00 },
291 : : { G_UNICODE_SCRIPT_SAMARITAN, 0x0800 },
292 : : { G_UNICODE_SCRIPT_TAI_THAM, 0x1A20 },
293 : : { G_UNICODE_SCRIPT_TAI_VIET, 0xAA80 },
294 : : { G_UNICODE_SCRIPT_BATAK, 0x1BC0 },
295 : : { G_UNICODE_SCRIPT_BRAHMI, 0x11000 },
296 : : { G_UNICODE_SCRIPT_MANDAIC, 0x0840 },
297 : : { G_UNICODE_SCRIPT_CHAKMA, 0x11100 },
298 : : { G_UNICODE_SCRIPT_MEROITIC_CURSIVE, 0x109A0 },
299 : : { G_UNICODE_SCRIPT_MEROITIC_HIEROGLYPHS, 0x10980 },
300 : : { G_UNICODE_SCRIPT_MIAO, 0x16F00 },
301 : : { G_UNICODE_SCRIPT_SHARADA, 0x11180 },
302 : : { G_UNICODE_SCRIPT_SORA_SOMPENG, 0x110D0 },
303 : : { G_UNICODE_SCRIPT_TAKRI, 0x11680 },
304 : : { G_UNICODE_SCRIPT_BASSA_VAH, 0x16AD0 },
305 : : { G_UNICODE_SCRIPT_CAUCASIAN_ALBANIAN, 0x10530 },
306 : : { G_UNICODE_SCRIPT_DUPLOYAN, 0x1BC00 },
307 : : { G_UNICODE_SCRIPT_ELBASAN, 0x10500 },
308 : : { G_UNICODE_SCRIPT_GRANTHA, 0x11301 },
309 : : { G_UNICODE_SCRIPT_KHOJKI, 0x11200 },
310 : : { G_UNICODE_SCRIPT_KHUDAWADI, 0x112B0 },
311 : : { G_UNICODE_SCRIPT_LINEAR_A, 0x10600 },
312 : : { G_UNICODE_SCRIPT_MAHAJANI, 0x11150 },
313 : : { G_UNICODE_SCRIPT_MANICHAEAN, 0x10AC0 },
314 : : { G_UNICODE_SCRIPT_MENDE_KIKAKUI, 0x1E800 },
315 : : { G_UNICODE_SCRIPT_MODI, 0x11600 },
316 : : { G_UNICODE_SCRIPT_MRO, 0x16A40 },
317 : : { G_UNICODE_SCRIPT_NABATAEAN, 0x10880 },
318 : : { G_UNICODE_SCRIPT_OLD_NORTH_ARABIAN, 0x10A80 },
319 : : { G_UNICODE_SCRIPT_OLD_PERMIC, 0x10350 },
320 : : { G_UNICODE_SCRIPT_PAHAWH_HMONG, 0x16B00 },
321 : : { G_UNICODE_SCRIPT_PALMYRENE, 0x10860 },
322 : : { G_UNICODE_SCRIPT_PAU_CIN_HAU, 0x11AC0 },
323 : : { G_UNICODE_SCRIPT_PSALTER_PAHLAVI, 0x10B80 },
324 : : { G_UNICODE_SCRIPT_SIDDHAM, 0x11580 },
325 : : { G_UNICODE_SCRIPT_TIRHUTA, 0x11480 },
326 : : { G_UNICODE_SCRIPT_WARANG_CITI, 0x118A0 },
327 : : { G_UNICODE_SCRIPT_CHEROKEE, 0x0AB71 },
328 : : { G_UNICODE_SCRIPT_HATRAN, 0x108E0 },
329 : : { G_UNICODE_SCRIPT_OLD_HUNGARIAN, 0x10C80 },
330 : : { G_UNICODE_SCRIPT_MULTANI, 0x11280 },
331 : : { G_UNICODE_SCRIPT_AHOM, 0x11700 },
332 : : { G_UNICODE_SCRIPT_CUNEIFORM, 0x12480 },
333 : : { G_UNICODE_SCRIPT_ANATOLIAN_HIEROGLYPHS, 0x14400 },
334 : : { G_UNICODE_SCRIPT_SIGNWRITING, 0x1D800 },
335 : : { G_UNICODE_SCRIPT_ADLAM, 0x1E900 },
336 : : { G_UNICODE_SCRIPT_BHAIKSUKI, 0x11C00 },
337 : : { G_UNICODE_SCRIPT_MARCHEN, 0x11C70 },
338 : : { G_UNICODE_SCRIPT_NEWA, 0x11400 },
339 : : { G_UNICODE_SCRIPT_OSAGE, 0x104B0 },
340 : : { G_UNICODE_SCRIPT_TANGUT, 0x16FE0 },
341 : : { G_UNICODE_SCRIPT_MASARAM_GONDI, 0x11D00 },
342 : : { G_UNICODE_SCRIPT_NUSHU, 0x1B170 },
343 : : { G_UNICODE_SCRIPT_SOYOMBO, 0x11A50 },
344 : : { G_UNICODE_SCRIPT_ZANABAZAR_SQUARE, 0x11A00 },
345 : : { G_UNICODE_SCRIPT_DOGRA, 0x11800 },
346 : : { G_UNICODE_SCRIPT_GUNJALA_GONDI, 0x11D60 },
347 : : { G_UNICODE_SCRIPT_HANIFI_ROHINGYA, 0x10D00 },
348 : : { G_UNICODE_SCRIPT_MAKASAR, 0x11EE0 },
349 : : { G_UNICODE_SCRIPT_MEDEFAIDRIN, 0x16E40 },
350 : : { G_UNICODE_SCRIPT_OLD_SOGDIAN, 0x10F00 },
351 : : { G_UNICODE_SCRIPT_SOGDIAN, 0x10F30 },
352 : : { G_UNICODE_SCRIPT_ELYMAIC, 0x10FE0 },
353 : : { G_UNICODE_SCRIPT_NANDINAGARI, 0x119A0 },
354 : : { G_UNICODE_SCRIPT_NYIAKENG_PUACHUE_HMONG, 0x1E100 },
355 : : { G_UNICODE_SCRIPT_WANCHO, 0x1E2C0 },
356 : : { G_UNICODE_SCRIPT_CHORASMIAN, 0x10FB0 },
357 : : { G_UNICODE_SCRIPT_DIVES_AKURU, 0x11900 },
358 : : { G_UNICODE_SCRIPT_KHITAN_SMALL_SCRIPT, 0x18B00 },
359 : : { G_UNICODE_SCRIPT_YEZIDI, 0x10E80 },
360 : : { G_UNICODE_SCRIPT_CYPRO_MINOAN, 0x12F90 },
361 : : { G_UNICODE_SCRIPT_OLD_UYGHUR, 0x10F70 },
362 : : { G_UNICODE_SCRIPT_TANGSA, 0x16A70 },
363 : : { G_UNICODE_SCRIPT_TOTO, 0x1E290 },
364 : : { G_UNICODE_SCRIPT_VITHKUQI, 0x10570 },
365 : : { G_UNICODE_SCRIPT_KAWI, 0x11F00 },
366 : : { G_UNICODE_SCRIPT_NAG_MUNDARI, 0x1E4D0 },
367 : : };
368 [ + + ]: 169 : for (i = 0; i < G_N_ELEMENTS (examples); i++)
369 : 168 : g_assert_cmpint (g_unichar_get_script (examples[i].c), ==, examples[i].script);
370 : 1 : }
371 : :
372 : : /* Test that g_unichar_combining_class() returns the correct value for
373 : : * various ASCII and Unicode alphabetic, numeric, and other, codepoints. */
374 : : static void
375 : 1 : test_combining_class (void)
376 : : {
377 : : guint i;
378 : : struct {
379 : : gint class;
380 : : gunichar c;
381 : 1 : } examples[] = {
382 : : { 0, 0x0020 },
383 : : { 1, 0x0334 },
384 : : { 7, 0x093C },
385 : : { 8, 0x3099 },
386 : : { 9, 0x094D },
387 : : { 10, 0x05B0 },
388 : : { 11, 0x05B1 },
389 : : { 12, 0x05B2 },
390 : : { 13, 0x05B3 },
391 : : { 14, 0x05B4 },
392 : : { 15, 0x05B5 },
393 : : { 16, 0x05B6 },
394 : : { 17, 0x05B7 },
395 : : { 18, 0x05B8 },
396 : : { 19, 0x05B9 },
397 : : { 20, 0x05BB },
398 : : { 21, 0x05BC },
399 : : { 22, 0x05BD },
400 : : { 23, 0x05BF },
401 : : { 24, 0x05C1 },
402 : : { 25, 0x05C2 },
403 : : { 26, 0xFB1E },
404 : : { 27, 0x064B },
405 : : { 28, 0x064C },
406 : : { 29, 0x064D },
407 : : /* ... */
408 : : { 228, 0x05AE },
409 : : { 230, 0x0300 },
410 : : { 232, 0x302C },
411 : : { 233, 0x0362 },
412 : : { 234, 0x0360 },
413 : : { 234, 0x1DCD },
414 : : { 240, 0x0345 }
415 : : };
416 [ + + ]: 33 : for (i = 0; i < G_N_ELEMENTS (examples); i++)
417 : : {
418 : 32 : g_assert_cmpint (g_unichar_combining_class (examples[i].c), ==, examples[i].class);
419 : : }
420 : 1 : }
421 : :
422 : : /* Test that g_unichar_get_mirror() returns the correct value for various
423 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
424 : : static void
425 : 1 : test_mirror (void)
426 : : {
427 : : gunichar mirror;
428 : :
429 : 1 : g_assert_true (g_unichar_get_mirror_char ('(', &mirror));
430 : 1 : g_assert_cmpint (mirror, ==, ')');
431 : 1 : g_assert_true (g_unichar_get_mirror_char (')', &mirror));
432 : 1 : g_assert_cmpint (mirror, ==, '(');
433 : 1 : g_assert_true (g_unichar_get_mirror_char ('{', &mirror));
434 : 1 : g_assert_cmpint (mirror, ==, '}');
435 : 1 : g_assert_true (g_unichar_get_mirror_char ('}', &mirror));
436 : 1 : g_assert_cmpint (mirror, ==, '{');
437 : 1 : g_assert_true (g_unichar_get_mirror_char (0x208D, &mirror));
438 : 1 : g_assert_cmpint (mirror, ==, 0x208E);
439 : 1 : g_assert_true (g_unichar_get_mirror_char (0x208E, &mirror));
440 : 1 : g_assert_cmpint (mirror, ==, 0x208D);
441 : 1 : g_assert_false (g_unichar_get_mirror_char ('a', &mirror));
442 : 1 : }
443 : :
444 : : /* Test that g_utf8_strup() returns the correct value for various
445 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
446 : : static void
447 : 1 : test_strup (void)
448 : : {
449 : 1 : char *str_up = NULL;
450 : 1 : const char *str = "AaZz09x;\x03\x45"
451 : : "\xEF\xBD\x81" /* Unichar 'A' (U+FF21) */
452 : : "\xEF\xBC\xA1"; /* Unichar 'a' (U+FF41) */
453 : :
454 : : /* Testing degenerated cases */
455 [ + - ]: 1 : if (g_test_undefined ())
456 : : {
457 : 1 : g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
458 : : "*assertion*!= NULL*");
459 : 1 : str_up = g_utf8_strup (NULL, 0);
460 : 1 : g_test_assert_expected_messages ();
461 : : }
462 : :
463 : 1 : str_up = g_utf8_strup (str, strlen (str));
464 : : /* Tricky, comparing two unicode strings with an ASCII function */
465 : 1 : g_assert_cmpstr (str_up, ==, "AAZZ09X;\003E\357\274\241\357\274\241");
466 : 1 : g_free (str_up);
467 : :
468 : 1 : str_up = g_utf8_strup ("", 0);
469 : 1 : g_assert_cmpstr (str_up, ==, "");
470 : 1 : g_free (str_up);
471 : 1 : }
472 : :
473 : : /* Test that g_utf8_strdown() returns the correct value for various
474 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
475 : : static void
476 : 1 : test_strdown (void)
477 : : {
478 : 1 : char *str_down = NULL;
479 : 1 : const char *str = "AaZz09x;\x03\x07"
480 : : "\xEF\xBD\x81" /* Unichar 'A' (U+FF21) */
481 : : "\xEF\xBC\xA1"; /* Unichar 'a' (U+FF41) */
482 : :
483 : : /* Testing degenerated cases */
484 [ + - ]: 1 : if (g_test_undefined ())
485 : : {
486 : 1 : g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
487 : : "*assertion*!= NULL*");
488 : 1 : str_down = g_utf8_strdown (NULL, 0);
489 : 1 : g_test_assert_expected_messages ();
490 : : }
491 : :
492 : 1 : str_down = g_utf8_strdown (str, strlen (str));
493 : : /* Tricky, comparing two unicode strings with an ASCII function */
494 : 1 : g_assert_cmpstr (str_down, ==, "aazz09x;\003\007\357\275\201\357\275\201");
495 : 1 : g_free (str_down);
496 : :
497 : 1 : str_down = g_utf8_strdown ("", 0);
498 : 1 : g_assert_cmpstr (str_down, ==, "");
499 : 1 : g_free (str_down);
500 : 1 : }
501 : :
502 : : /* Test that g_utf8_strup() and g_utf8_strdown() return the correct
503 : : * value for Turkish 'i' with and without dot above. */
504 : : static void
505 : 1 : test_turkish_strupdown (void)
506 : : {
507 : 1 : char *str_up = NULL;
508 : 1 : char *str_down = NULL;
509 : 1 : const char *str = "iII"
510 : : "\xcc\x87" /* COMBINING DOT ABOVE (U+307) */
511 : : "\xc4\xb1" /* LATIN SMALL LETTER DOTLESS I (U+131) */
512 : : "\xc4\xb0"; /* LATIN CAPITAL LETTER I WITH DOT ABOVE (U+130) */
513 : : char *oldlocale;
514 : : char *old_lc_all, *old_lc_messages, *old_lang;
515 : : #ifdef G_OS_WIN32
516 : : LCID old_lcid;
517 : : #endif
518 : :
519 : : /* interferes with g_win32_getlocale() */
520 : 1 : save_and_clear_env ("LC_ALL", &old_lc_all);
521 : 1 : save_and_clear_env ("LC_MESSAGES", &old_lc_messages);
522 : 1 : save_and_clear_env ("LANG", &old_lang);
523 : :
524 : 1 : oldlocale = g_strdup (setlocale (LC_ALL, "tr_TR"));
525 [ - + ]: 1 : if (oldlocale == NULL)
526 : : {
527 : 0 : g_test_skip ("locale tr_TR not available");
528 : 0 : return;
529 : : }
530 : :
531 : : #ifdef G_OS_WIN32
532 : : old_lcid = GetThreadLocale ();
533 : : SetThreadLocale (MAKELCID (MAKELANGID (LANG_TURKISH, SUBLANG_TURKISH_TURKEY), SORT_DEFAULT));
534 : : #endif
535 : :
536 : 1 : str_up = g_utf8_strup (str, strlen (str));
537 : 1 : str_down = g_utf8_strdown (str, strlen (str));
538 : : /* i => LATIN CAPITAL LETTER I WITH DOT ABOVE,
539 : : * I => I,
540 : : * I + COMBINING DOT ABOVE => I + COMBINING DOT ABOVE,
541 : : * LATIN SMALL LETTER DOTLESS I => I,
542 : : * LATIN CAPITAL LETTER I WITH DOT ABOVE => LATIN CAPITAL LETTER I WITH DOT ABOVE */
543 : 1 : g_assert_cmpstr (str_up, ==, "\xc4\xb0II\xcc\x87I\xc4\xb0");
544 : : /* i => i,
545 : : * I => LATIN SMALL LETTER DOTLESS I,
546 : : * I + COMBINING DOT ABOVE => i,
547 : : * LATIN SMALL LETTER DOTLESS I => LATIN SMALL LETTER DOTLESS I,
548 : : * LATIN CAPITAL LETTER I WITH DOT ABOVE => i */
549 : 1 : g_assert_cmpstr (str_down, ==, "i\xc4\xb1i\xc4\xb1i");
550 : 1 : g_free (str_up);
551 : 1 : g_free (str_down);
552 : :
553 : 1 : setlocale (LC_ALL, oldlocale);
554 : : #ifdef G_OS_WIN32
555 : : SetThreadLocale (old_lcid);
556 : : #endif
557 : 1 : g_free (oldlocale);
558 [ - + ]: 1 : if (old_lc_all)
559 : 0 : g_setenv ("LC_ALL", old_lc_all, TRUE);
560 [ - + ]: 1 : if (old_lc_messages)
561 : 0 : g_setenv ("LC_MESSAGES", old_lc_messages, TRUE);
562 [ + - ]: 1 : if (old_lang)
563 : 1 : g_setenv ("LANG", old_lang, TRUE);
564 : 1 : g_free (old_lc_all);
565 : 1 : g_free (old_lc_messages);
566 : 1 : g_free (old_lang);
567 : : }
568 : :
569 : : /* Test that g_utf8_casefold() returns the correct value for various
570 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
571 : : static void
572 : 1 : test_casefold (void)
573 : : {
574 : 1 : char *str_casefold = NULL;
575 : 1 : const char *str = "AaZz09x;"
576 : : "\xEF\xBD\x81" /* Unichar 'A' (U+FF21) */
577 : : "\xEF\xBC\xA1"; /* Unichar 'a' (U+FF41) */
578 : :
579 : : /* Testing degenerated cases */
580 [ + - ]: 1 : if (g_test_undefined ())
581 : : {
582 : 1 : g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
583 : : "*assertion*!= NULL*");
584 : 1 : str_casefold = g_utf8_casefold (NULL, 0);
585 : 1 : g_test_assert_expected_messages ();
586 : : }
587 : :
588 : 1 : str_casefold = g_utf8_casefold (str, strlen (str));
589 : : /* Tricky, comparing two unicode strings with an ASCII function */
590 : 1 : g_assert_cmpstr (str_casefold, ==, "aazz09x;\357\275\201\357\275\201");
591 : 1 : g_free (str_casefold);
592 : :
593 : 1 : str_casefold = g_utf8_casefold ("", 0);
594 : 1 : g_assert_cmpstr (str_casefold, ==, "");
595 : 1 : g_free (str_casefold);
596 : 1 : }
597 : :
598 : : static void
599 : 1 : test_casemap_and_casefold (void)
600 : : {
601 : : FILE *infile;
602 : : char buffer[1024];
603 : : char **strings;
604 : : char *filename;
605 : : const char *locale;
606 : : const char *test;
607 : : const char *expected;
608 : : char *convert;
609 : 1 : char *current_locale = setlocale (LC_CTYPE, NULL);
610 : : char *old_lc_all, *old_lc_messages, *old_lang;
611 : : #ifdef G_OS_WIN32
612 : : LCID old_lcid;
613 : :
614 : : old_lcid = GetThreadLocale ();
615 : : #endif
616 : :
617 : : /* interferes with g_win32_getlocale() */
618 : 1 : save_and_clear_env ("LC_ALL", &old_lc_all);
619 : 1 : save_and_clear_env ("LC_MESSAGES", &old_lc_messages);
620 : 1 : save_and_clear_env ("LANG", &old_lang);
621 : :
622 : 1 : filename = g_test_build_filename (G_TEST_DIST, "casemap.txt", NULL);
623 : 1 : infile = fopen (filename, "r");
624 : 1 : g_assert (infile != NULL);
625 : :
626 [ + + ]: 4142 : while (fgets (buffer, sizeof (buffer), infile))
627 : : {
628 [ + + ]: 4141 : if (buffer[0] == '#')
629 : 13 : continue;
630 : :
631 : 4128 : strings = g_strsplit (buffer, "\t", -1);
632 : 4128 : locale = strings[0];
633 [ + + ]: 4128 : if (!locale[0])
634 : 4100 : locale = "C";
635 : :
636 [ + + ]: 4128 : if (strcmp (locale, current_locale) != 0)
637 : : {
638 : 6 : setlocale (LC_CTYPE, locale);
639 : 6 : current_locale = setlocale (LC_CTYPE, NULL);
640 : :
641 [ - + ]: 6 : if (strncmp (current_locale, locale, 2) != 0)
642 : : {
643 : 0 : g_test_message ("Cannot set locale to %s, skipping", locale);
644 : 0 : goto next;
645 : : }
646 : : }
647 : :
648 : : #ifdef G_OS_WIN32
649 : : if (strstr (locale, "lt_LT"))
650 : : SetThreadLocale (MAKELCID (MAKELANGID (LANG_LITHUANIAN, SUBLANG_LITHUANIAN), SORT_DEFAULT));
651 : : else if (strstr (locale, "tr_TR"))
652 : : SetThreadLocale (MAKELCID (MAKELANGID (LANG_TURKISH, SUBLANG_TURKISH_TURKEY), SORT_DEFAULT));
653 : : else
654 : : SetThreadLocale (old_lcid);
655 : : #endif
656 : :
657 : 4128 : test = strings[1];
658 : :
659 : : /* gen-casemap-txt.py uses an empty string when a single
660 : : * character doesn't have an equivalent in a particular case;
661 : : * since that behavior is nonsense for multicharacter strings,
662 : : * it would make more sense to put the expected result ... the
663 : : * original character unchanged. But for now, we just work
664 : : * around it here and take the empty string to mean "same as
665 : : * original"
666 : : */
667 : :
668 : 4128 : convert = g_utf8_strup (test, -1);
669 [ + + ]: 4128 : expected = strings[4][0] ? strings[4] : test;
670 : 4128 : g_assert_cmpstr (convert, ==, expected);
671 : 4128 : g_free (convert);
672 : :
673 : 4128 : convert = g_utf8_strdown (test, -1);
674 [ + + ]: 4128 : expected = strings[2][0] ? strings[2] : test;
675 : 4128 : g_assert_cmpstr (convert, ==, expected);
676 : 4128 : g_free (convert);
677 : :
678 : 4128 : next:
679 : 4128 : g_strfreev (strings);
680 : : }
681 : :
682 : 1 : fclose (infile);
683 : :
684 : 1 : g_free (filename);
685 : 1 : filename = g_test_build_filename (G_TEST_DIST, "casefold.txt", NULL);
686 : :
687 : 1 : infile = fopen (filename, "r");
688 : 1 : g_assert (infile != NULL);
689 : :
690 [ + + ]: 1540 : while (fgets (buffer, sizeof (buffer), infile))
691 : : {
692 [ + + ]: 1539 : if (buffer[0] == '#')
693 : 8 : continue;
694 : :
695 : 1531 : buffer[strlen (buffer) - 1] = '\0';
696 : 1531 : strings = g_strsplit (buffer, "\t", -1);
697 : :
698 : 1531 : test = strings[0];
699 : :
700 : 1531 : convert = g_utf8_casefold (test, -1);
701 : 1531 : g_assert_cmpstr (convert, ==, strings[1]);
702 : 1531 : g_free (convert);
703 : :
704 : 1531 : g_strfreev (strings);
705 : : }
706 : :
707 : 1 : fclose (infile);
708 : 1 : g_free (filename);
709 : :
710 [ - + ]: 1 : if (old_lc_all)
711 : 0 : g_setenv ("LC_ALL", old_lc_all, TRUE);
712 [ - + ]: 1 : if (old_lc_messages)
713 : 0 : g_setenv ("LC_MESSAGES", old_lc_messages, TRUE);
714 [ + - ]: 1 : if (old_lang)
715 : 1 : g_setenv ("LANG", old_lang, TRUE);
716 : 1 : g_free (old_lc_all);
717 : 1 : g_free (old_lc_messages);
718 : 1 : g_free (old_lang);
719 : : #ifdef G_OS_WIN32
720 : : SetThreadLocale (old_lcid);
721 : : #endif
722 : 1 : }
723 : :
724 : : /* Test that g_unichar_ismark() returns the correct value for various
725 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
726 : : static void
727 : 1 : test_mark (void)
728 : : {
729 : 1 : g_assert_true (g_unichar_ismark (0x0903));
730 : 1 : g_assert_true (g_unichar_ismark (0x20DD));
731 : 1 : g_assert_true (g_unichar_ismark (0xA806));
732 : 1 : g_assert_false (g_unichar_ismark ('a'));
733 : :
734 : : /*** Testing TYPE() border cases ***/
735 : 1 : g_assert_false (g_unichar_ismark (0x3FF5));
736 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
737 : 1 : g_assert_false (g_unichar_ismark (0xFFEFF));
738 : : /* U+E0001 Language Tag */
739 : 1 : g_assert_false (g_unichar_ismark (0xE0001));
740 : 1 : g_assert_false (g_unichar_ismark (G_UNICODE_LAST_CHAR));
741 : 1 : g_assert_false (g_unichar_ismark (G_UNICODE_LAST_CHAR + 1));
742 : 1 : g_assert_false (g_unichar_ismark (G_UNICODE_LAST_CHAR_PART1));
743 : 1 : g_assert_false (g_unichar_ismark (G_UNICODE_LAST_CHAR_PART1 + 1));
744 : 1 : }
745 : :
746 : : /* Test that g_unichar_isspace() returns the correct value for various
747 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
748 : : static void
749 : 1 : test_space (void)
750 : : {
751 : 1 : g_assert_false (g_unichar_isspace ('a'));
752 : 1 : g_assert_true (g_unichar_isspace (' '));
753 : 1 : g_assert_true (g_unichar_isspace ('\t'));
754 : 1 : g_assert_true (g_unichar_isspace ('\n'));
755 : 1 : g_assert_true (g_unichar_isspace ('\r'));
756 : 1 : g_assert_true (g_unichar_isspace ('\f'));
757 : 1 : g_assert_false (g_unichar_isspace (0xff41)); /* Unicode fullwidth 'a' */
758 : 1 : g_assert_true (g_unichar_isspace (0x202F)); /* Unicode space separator */
759 : 1 : g_assert_true (g_unichar_isspace (0x2028)); /* Unicode line separator */
760 : 1 : g_assert_true (g_unichar_isspace (0x2029)); /* Unicode paragraph separator */
761 : :
762 : : /*** Testing TYPE() border cases ***/
763 : 1 : g_assert_false (g_unichar_isspace (0x3FF5));
764 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
765 : 1 : g_assert_false (g_unichar_isspace (0xFFEFF));
766 : : /* U+E0001 Language Tag */
767 : 1 : g_assert_false (g_unichar_isspace (0xE0001));
768 : 1 : g_assert_false (g_unichar_isspace (G_UNICODE_LAST_CHAR));
769 : 1 : g_assert_false (g_unichar_isspace (G_UNICODE_LAST_CHAR + 1));
770 : 1 : g_assert_false (g_unichar_isspace (G_UNICODE_LAST_CHAR_PART1));
771 : 1 : g_assert_false (g_unichar_isspace (G_UNICODE_LAST_CHAR_PART1 + 1));
772 : 1 : }
773 : :
774 : : /* Test that g_unichar_isalnum() returns the correct value for various
775 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
776 : : static void
777 : 1 : test_alnum (void)
778 : : {
779 : 1 : g_assert_false (g_unichar_isalnum (' '));
780 : 1 : g_assert_true (g_unichar_isalnum ('a'));
781 : 1 : g_assert_true (g_unichar_isalnum ('z'));
782 : 1 : g_assert_true (g_unichar_isalnum ('0'));
783 : 1 : g_assert_true (g_unichar_isalnum ('9'));
784 : 1 : g_assert_true (g_unichar_isalnum ('A'));
785 : 1 : g_assert_true (g_unichar_isalnum ('Z'));
786 : 1 : g_assert_false (g_unichar_isalnum ('-'));
787 : 1 : g_assert_false (g_unichar_isalnum ('*'));
788 : 1 : g_assert_true (g_unichar_isalnum (0xFF21)); /* Unichar fullwidth 'A' */
789 : 1 : g_assert_true (g_unichar_isalnum (0xFF3A)); /* Unichar fullwidth 'Z' */
790 : 1 : g_assert_true (g_unichar_isalnum (0xFF41)); /* Unichar fullwidth 'a' */
791 : 1 : g_assert_true (g_unichar_isalnum (0xFF5A)); /* Unichar fullwidth 'z' */
792 : 1 : g_assert_true (g_unichar_isalnum (0xFF10)); /* Unichar fullwidth '0' */
793 : 1 : g_assert_true (g_unichar_isalnum (0xFF19)); /* Unichar fullwidth '9' */
794 : 1 : g_assert_false (g_unichar_isalnum (0xFF0A)); /* Unichar fullwidth '*' */
795 : :
796 : : /*** Testing TYPE() border cases ***/
797 : 1 : g_assert_true (g_unichar_isalnum (0x3FF5));
798 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
799 : 1 : g_assert_false (g_unichar_isalnum (0xFFEFF));
800 : : /* U+E0001 Language Tag */
801 : 1 : g_assert_false (g_unichar_isalnum (0xE0001));
802 : 1 : g_assert_false (g_unichar_isalnum (G_UNICODE_LAST_CHAR));
803 : 1 : g_assert_false (g_unichar_isalnum (G_UNICODE_LAST_CHAR + 1));
804 : 1 : g_assert_false (g_unichar_isalnum (G_UNICODE_LAST_CHAR_PART1));
805 : 1 : g_assert_false (g_unichar_isalnum (G_UNICODE_LAST_CHAR_PART1 + 1));
806 : 1 : }
807 : :
808 : : /* Test that g_unichar_isalpha() returns the correct value for various
809 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
810 : : static void
811 : 1 : test_alpha (void)
812 : : {
813 : 1 : g_assert_false (g_unichar_isalpha (' '));
814 : 1 : g_assert_true (g_unichar_isalpha ('a'));
815 : 1 : g_assert_true (g_unichar_isalpha ('z'));
816 : 1 : g_assert_false (g_unichar_isalpha ('0'));
817 : 1 : g_assert_false (g_unichar_isalpha ('9'));
818 : 1 : g_assert_true (g_unichar_isalpha ('A'));
819 : 1 : g_assert_true (g_unichar_isalpha ('Z'));
820 : 1 : g_assert_false (g_unichar_isalpha ('-'));
821 : 1 : g_assert_false (g_unichar_isalpha ('*'));
822 : 1 : g_assert_true (g_unichar_isalpha (0xFF21)); /* Unichar fullwidth 'A' */
823 : 1 : g_assert_true (g_unichar_isalpha (0xFF3A)); /* Unichar fullwidth 'Z' */
824 : 1 : g_assert_true (g_unichar_isalpha (0xFF41)); /* Unichar fullwidth 'a' */
825 : 1 : g_assert_true (g_unichar_isalpha (0xFF5A)); /* Unichar fullwidth 'z' */
826 : 1 : g_assert_false (g_unichar_isalpha (0xFF10)); /* Unichar fullwidth '0' */
827 : 1 : g_assert_false (g_unichar_isalpha (0xFF19)); /* Unichar fullwidth '9' */
828 : 1 : g_assert_false (g_unichar_isalpha (0xFF0A)); /* Unichar fullwidth '*' */
829 : :
830 : : /*** Testing TYPE() border cases ***/
831 : 1 : g_assert_true (g_unichar_isalpha (0x3FF5));
832 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
833 : 1 : g_assert_false (g_unichar_isalpha (0xFFEFF));
834 : : /* U+E0001 Language Tag */
835 : 1 : g_assert_false (g_unichar_isalpha (0xE0001));
836 : 1 : g_assert_false (g_unichar_isalpha (G_UNICODE_LAST_CHAR));
837 : 1 : g_assert_false (g_unichar_isalpha (G_UNICODE_LAST_CHAR + 1));
838 : 1 : g_assert_false (g_unichar_isalpha (G_UNICODE_LAST_CHAR_PART1));
839 : 1 : g_assert_false (g_unichar_isalpha (G_UNICODE_LAST_CHAR_PART1 + 1));
840 : 1 : }
841 : :
842 : : /* Test that g_unichar_isdigit() returns the correct value for various
843 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
844 : : static void
845 : 1 : test_digit (void)
846 : : {
847 : 1 : g_assert_false (g_unichar_isdigit (' '));
848 : 1 : g_assert_false (g_unichar_isdigit ('a'));
849 : 1 : g_assert_true (g_unichar_isdigit ('0'));
850 : 1 : g_assert_true (g_unichar_isdigit ('9'));
851 : 1 : g_assert_false (g_unichar_isdigit ('A'));
852 : 1 : g_assert_false (g_unichar_isdigit ('-'));
853 : 1 : g_assert_false (g_unichar_isdigit ('*'));
854 : 1 : g_assert_false (g_unichar_isdigit (0xFF21)); /* Unichar fullwidth 'A' */
855 : 1 : g_assert_false (g_unichar_isdigit (0xFF3A)); /* Unichar fullwidth 'Z' */
856 : 1 : g_assert_false (g_unichar_isdigit (0xFF41)); /* Unichar fullwidth 'a' */
857 : 1 : g_assert_false (g_unichar_isdigit (0xFF5A)); /* Unichar fullwidth 'z' */
858 : 1 : g_assert_true (g_unichar_isdigit (0xFF10)); /* Unichar fullwidth '0' */
859 : 1 : g_assert_true (g_unichar_isdigit (0xFF19)); /* Unichar fullwidth '9' */
860 : 1 : g_assert_false (g_unichar_isdigit (0xFF0A)); /* Unichar fullwidth '*' */
861 : :
862 : : /*** Testing TYPE() border cases ***/
863 : 1 : g_assert_false (g_unichar_isdigit (0x3FF5));
864 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
865 : 1 : g_assert_false (g_unichar_isdigit (0xFFEFF));
866 : : /* U+E0001 Language Tag */
867 : 1 : g_assert_false (g_unichar_isdigit (0xE0001));
868 : 1 : g_assert_false (g_unichar_isdigit (G_UNICODE_LAST_CHAR));
869 : 1 : g_assert_false (g_unichar_isdigit (G_UNICODE_LAST_CHAR + 1));
870 : 1 : g_assert_false (g_unichar_isdigit (G_UNICODE_LAST_CHAR_PART1));
871 : 1 : g_assert_false (g_unichar_isdigit (G_UNICODE_LAST_CHAR_PART1 + 1));
872 : 1 : }
873 : :
874 : : /* Test that g_unichar_digit_value() returns the correct value for various
875 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
876 : : static void
877 : 1 : test_digit_value (void)
878 : : {
879 : 1 : g_assert_cmpint (g_unichar_digit_value (' '), ==, -1);
880 : 1 : g_assert_cmpint (g_unichar_digit_value ('a'), ==, -1);
881 : 1 : g_assert_cmpint (g_unichar_digit_value ('0'), ==, 0);
882 : 1 : g_assert_cmpint (g_unichar_digit_value ('9'), ==, 9);
883 : 1 : g_assert_cmpint (g_unichar_digit_value ('A'), ==, -1);
884 : 1 : g_assert_cmpint (g_unichar_digit_value ('-'), ==, -1);
885 : 1 : g_assert_cmpint (g_unichar_digit_value (0xFF21), ==, -1); /* Unichar 'A' */
886 : 1 : g_assert_cmpint (g_unichar_digit_value (0xFF3A), ==, -1); /* Unichar 'Z' */
887 : 1 : g_assert_cmpint (g_unichar_digit_value (0xFF41), ==, -1); /* Unichar 'a' */
888 : 1 : g_assert_cmpint (g_unichar_digit_value (0xFF5A), ==, -1); /* Unichar 'z' */
889 : 1 : g_assert_cmpint (g_unichar_digit_value (0xFF10), ==, 0); /* Unichar '0' */
890 : 1 : g_assert_cmpint (g_unichar_digit_value (0xFF19), ==, 9); /* Unichar '9' */
891 : 1 : g_assert_cmpint (g_unichar_digit_value (0xFF0A), ==, -1); /* Unichar '*' */
892 : :
893 : : /*** Testing TYPE() border cases ***/
894 : 1 : g_assert_cmpint (g_unichar_digit_value (0x3FF5), ==, -1);
895 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
896 : 1 : g_assert_cmpint (g_unichar_digit_value (0xFFEFF), ==, -1);
897 : : /* U+E0001 Language Tag */
898 : 1 : g_assert_cmpint (g_unichar_digit_value (0xE0001), ==, -1);
899 : 1 : g_assert_cmpint (g_unichar_digit_value (G_UNICODE_LAST_CHAR), ==, -1);
900 : 1 : g_assert_cmpint (g_unichar_digit_value (G_UNICODE_LAST_CHAR + 1), ==, -1);
901 : 1 : g_assert_cmpint (g_unichar_digit_value (G_UNICODE_LAST_CHAR_PART1), ==, -1);
902 : 1 : g_assert_cmpint (g_unichar_digit_value (G_UNICODE_LAST_CHAR_PART1 + 1), ==, -1);
903 : 1 : }
904 : :
905 : : /* Test that g_unichar_isxdigit() returns the correct value for various
906 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
907 : : static void
908 : 1 : test_xdigit (void)
909 : : {
910 : 1 : g_assert_false (g_unichar_isxdigit (' '));
911 : 1 : g_assert_true (g_unichar_isxdigit ('a'));
912 : 1 : g_assert_true (g_unichar_isxdigit ('f'));
913 : 1 : g_assert_false (g_unichar_isxdigit ('g'));
914 : 1 : g_assert_false (g_unichar_isxdigit ('z'));
915 : 1 : g_assert_true (g_unichar_isxdigit ('0'));
916 : 1 : g_assert_true (g_unichar_isxdigit ('9'));
917 : 1 : g_assert_true (g_unichar_isxdigit ('A'));
918 : 1 : g_assert_true (g_unichar_isxdigit ('F'));
919 : 1 : g_assert_false (g_unichar_isxdigit ('G'));
920 : 1 : g_assert_false (g_unichar_isxdigit ('Z'));
921 : 1 : g_assert_false (g_unichar_isxdigit ('-'));
922 : 1 : g_assert_false (g_unichar_isxdigit ('*'));
923 : 1 : g_assert_true (g_unichar_isxdigit (0xFF21)); /* Unichar fullwidth 'A' */
924 : 1 : g_assert_true (g_unichar_isxdigit (0xFF26)); /* Unichar fullwidth 'F' */
925 : 1 : g_assert_false (g_unichar_isxdigit (0xFF27)); /* Unichar fullwidth 'G' */
926 : 1 : g_assert_false (g_unichar_isxdigit (0xFF3A)); /* Unichar fullwidth 'Z' */
927 : 1 : g_assert_true (g_unichar_isxdigit (0xFF41)); /* Unichar fullwidth 'a' */
928 : 1 : g_assert_true (g_unichar_isxdigit (0xFF46)); /* Unichar fullwidth 'f' */
929 : 1 : g_assert_false (g_unichar_isxdigit (0xFF47)); /* Unichar fullwidth 'g' */
930 : 1 : g_assert_false (g_unichar_isxdigit (0xFF5A)); /* Unichar fullwidth 'z' */
931 : 1 : g_assert_true (g_unichar_isxdigit (0xFF10)); /* Unichar fullwidth '0' */
932 : 1 : g_assert_true (g_unichar_isxdigit (0xFF19)); /* Unichar fullwidth '9' */
933 : 1 : g_assert_false (g_unichar_isxdigit (0xFF0A)); /* Unichar fullwidth '*' */
934 : :
935 : : /*** Testing TYPE() border cases ***/
936 : 1 : g_assert_false (g_unichar_isxdigit (0x3FF5));
937 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
938 : 1 : g_assert_false (g_unichar_isxdigit (0xFFEFF));
939 : : /* U+E0001 Language Tag */
940 : 1 : g_assert_false (g_unichar_isxdigit (0xE0001));
941 : 1 : g_assert_false (g_unichar_isxdigit (G_UNICODE_LAST_CHAR));
942 : 1 : g_assert_false (g_unichar_isxdigit (G_UNICODE_LAST_CHAR + 1));
943 : 1 : g_assert_false (g_unichar_isxdigit (G_UNICODE_LAST_CHAR_PART1));
944 : 1 : g_assert_false (g_unichar_isxdigit (G_UNICODE_LAST_CHAR_PART1 + 1));
945 : 1 : }
946 : :
947 : : /* Test that g_unichar_xdigit_value() returns the correct value for various
948 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
949 : : static void
950 : 1 : test_xdigit_value (void)
951 : : {
952 : 1 : g_assert_cmpint (g_unichar_xdigit_value (' '), ==, -1);
953 : 1 : g_assert_cmpint (g_unichar_xdigit_value ('a'), ==, 10);
954 : 1 : g_assert_cmpint (g_unichar_xdigit_value ('f'), ==, 15);
955 : 1 : g_assert_cmpint (g_unichar_xdigit_value ('g'), ==, -1);
956 : 1 : g_assert_cmpint (g_unichar_xdigit_value ('0'), ==, 0);
957 : 1 : g_assert_cmpint (g_unichar_xdigit_value ('9'), ==, 9);
958 : 1 : g_assert_cmpint (g_unichar_xdigit_value ('A'), ==, 10);
959 : 1 : g_assert_cmpint (g_unichar_xdigit_value ('F'), ==, 15);
960 : 1 : g_assert_cmpint (g_unichar_xdigit_value ('G'), ==, -1);
961 : 1 : g_assert_cmpint (g_unichar_xdigit_value ('-'), ==, -1);
962 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xFF21), ==, 10); /* Unichar 'A' */
963 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xFF26), ==, 15); /* Unichar 'F' */
964 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xFF27), ==, -1); /* Unichar 'G' */
965 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xFF3A), ==, -1); /* Unichar 'Z' */
966 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xFF41), ==, 10); /* Unichar 'a' */
967 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xFF46), ==, 15); /* Unichar 'f' */
968 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xFF47), ==, -1); /* Unichar 'g' */
969 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xFF5A), ==, -1); /* Unichar 'z' */
970 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xFF10), ==, 0); /* Unichar '0' */
971 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xFF19), ==, 9); /* Unichar '9' */
972 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xFF0A), ==, -1); /* Unichar '*' */
973 : :
974 : : /*** Testing TYPE() border cases ***/
975 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0x3FF5), ==, -1);
976 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
977 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xFFEFF), ==, -1);
978 : : /* U+E0001 Language Tag */
979 : 1 : g_assert_cmpint (g_unichar_xdigit_value (0xE0001), ==, -1);
980 : 1 : g_assert_cmpint (g_unichar_xdigit_value (G_UNICODE_LAST_CHAR), ==, -1);
981 : 1 : g_assert_cmpint (g_unichar_xdigit_value (G_UNICODE_LAST_CHAR + 1), ==, -1);
982 : 1 : g_assert_cmpint (g_unichar_xdigit_value (G_UNICODE_LAST_CHAR_PART1), ==, -1);
983 : 1 : g_assert_cmpint (g_unichar_xdigit_value (G_UNICODE_LAST_CHAR_PART1 + 1), ==, -1);
984 : 1 : }
985 : :
986 : : /* Test that g_unichar_ispunct() returns the correct value for various
987 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
988 : : static void
989 : 1 : test_punctuation (void)
990 : : {
991 : 1 : g_assert_false (g_unichar_ispunct (' '));
992 : 1 : g_assert_false (g_unichar_ispunct ('a'));
993 : 1 : g_assert_true (g_unichar_ispunct ('.'));
994 : 1 : g_assert_true (g_unichar_ispunct (','));
995 : 1 : g_assert_true (g_unichar_ispunct (';'));
996 : 1 : g_assert_true (g_unichar_ispunct (':'));
997 : 1 : g_assert_true (g_unichar_ispunct ('-'));
998 : :
999 : 1 : g_assert_false (g_unichar_ispunct (0xFF21)); /* Unichar fullwidth 'A' */
1000 : 1 : g_assert_true (g_unichar_ispunct (0x005F)); /* Unichar fullwidth '.' */
1001 : 1 : g_assert_true (g_unichar_ispunct (0x058A)); /* Unichar fullwidth '-' */
1002 : :
1003 : : /*** Testing TYPE() border cases ***/
1004 : 1 : g_assert_false (g_unichar_ispunct (0x3FF5));
1005 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
1006 : 1 : g_assert_false (g_unichar_ispunct (0xFFEFF));
1007 : : /* U+E0001 Language Tag */
1008 : 1 : g_assert_false (g_unichar_ispunct (0xE0001));
1009 : 1 : g_assert_false (g_unichar_ispunct (G_UNICODE_LAST_CHAR));
1010 : 1 : g_assert_false (g_unichar_ispunct (G_UNICODE_LAST_CHAR + 1));
1011 : 1 : g_assert_false (g_unichar_ispunct (G_UNICODE_LAST_CHAR_PART1));
1012 : 1 : g_assert_false (g_unichar_ispunct (G_UNICODE_LAST_CHAR_PART1 + 1));
1013 : 1 : }
1014 : :
1015 : : /* Test that g_unichar_iscntrl() returns the correct value for various
1016 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
1017 : : static void
1018 : 1 : test_cntrl (void)
1019 : : {
1020 : 1 : g_assert_true (g_unichar_iscntrl (0x08));
1021 : 1 : g_assert_false (g_unichar_iscntrl ('a'));
1022 : 1 : g_assert_true (g_unichar_iscntrl (0x007F)); /* Unichar fullwidth <del> */
1023 : 1 : g_assert_true (g_unichar_iscntrl (0x009F)); /* Unichar fullwidth control */
1024 : :
1025 : : /*** Testing TYPE() border cases ***/
1026 : 1 : g_assert_false (g_unichar_iscntrl (0x3FF5));
1027 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
1028 : 1 : g_assert_false (g_unichar_iscntrl (0xFFEFF));
1029 : : /* U+E0001 Language Tag */
1030 : 1 : g_assert_false (g_unichar_iscntrl (0xE0001));
1031 : 1 : g_assert_false (g_unichar_iscntrl (G_UNICODE_LAST_CHAR));
1032 : 1 : g_assert_false (g_unichar_iscntrl (G_UNICODE_LAST_CHAR + 1));
1033 : 1 : g_assert_false (g_unichar_iscntrl (G_UNICODE_LAST_CHAR_PART1));
1034 : 1 : g_assert_false (g_unichar_iscntrl (G_UNICODE_LAST_CHAR_PART1 + 1));
1035 : 1 : }
1036 : :
1037 : : /* Test that g_unichar_isgraph() returns the correct value for various
1038 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
1039 : : static void
1040 : 1 : test_graph (void)
1041 : : {
1042 : 1 : g_assert_false (g_unichar_isgraph (0x08));
1043 : 1 : g_assert_false (g_unichar_isgraph (' '));
1044 : 1 : g_assert_true (g_unichar_isgraph ('a'));
1045 : 1 : g_assert_true (g_unichar_isgraph ('0'));
1046 : 1 : g_assert_true (g_unichar_isgraph ('9'));
1047 : 1 : g_assert_true (g_unichar_isgraph ('A'));
1048 : 1 : g_assert_true (g_unichar_isgraph ('-'));
1049 : 1 : g_assert_true (g_unichar_isgraph ('*'));
1050 : 1 : g_assert_true (g_unichar_isgraph (0xFF21)); /* Unichar fullwidth 'A' */
1051 : 1 : g_assert_true (g_unichar_isgraph (0xFF3A)); /* Unichar fullwidth 'Z' */
1052 : 1 : g_assert_true (g_unichar_isgraph (0xFF41)); /* Unichar fullwidth 'a' */
1053 : 1 : g_assert_true (g_unichar_isgraph (0xFF5A)); /* Unichar fullwidth 'z' */
1054 : 1 : g_assert_true (g_unichar_isgraph (0xFF10)); /* Unichar fullwidth '0' */
1055 : 1 : g_assert_true (g_unichar_isgraph (0xFF19)); /* Unichar fullwidth '9' */
1056 : 1 : g_assert_true (g_unichar_isgraph (0xFF0A)); /* Unichar fullwidth '*' */
1057 : 1 : g_assert_false (g_unichar_isgraph (0x007F)); /* Unichar fullwidth <del> */
1058 : 1 : g_assert_false (g_unichar_isgraph (0x009F)); /* Unichar fullwidth control */
1059 : :
1060 : : /*** Testing TYPE() border cases ***/
1061 : 1 : g_assert_true (g_unichar_isgraph (0x3FF5));
1062 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
1063 : 1 : g_assert_true (g_unichar_isgraph (0xFFEFF));
1064 : : /* U+E0001 Language Tag */
1065 : 1 : g_assert_false (g_unichar_isgraph (0xE0001));
1066 : 1 : g_assert_false (g_unichar_isgraph (G_UNICODE_LAST_CHAR));
1067 : 1 : g_assert_false (g_unichar_isgraph (G_UNICODE_LAST_CHAR + 1));
1068 : 1 : g_assert_false (g_unichar_isgraph (G_UNICODE_LAST_CHAR_PART1));
1069 : 1 : g_assert_false (g_unichar_isgraph (G_UNICODE_LAST_CHAR_PART1 + 1));
1070 : 1 : }
1071 : :
1072 : : /* Test that g_unichar_iszerowidth() returns the correct value for various
1073 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
1074 : : static void
1075 : 1 : test_zerowidth (void)
1076 : : {
1077 : 1 : g_assert_false (g_unichar_iszerowidth (0x00AD));
1078 : 1 : g_assert_false (g_unichar_iszerowidth (0x115F));
1079 : 1 : g_assert_true (g_unichar_iszerowidth (0x1160));
1080 : 1 : g_assert_true (g_unichar_iszerowidth (0x11AA));
1081 : 1 : g_assert_true (g_unichar_iszerowidth (0x11FF));
1082 : 1 : g_assert_false (g_unichar_iszerowidth (0x1200));
1083 : 1 : g_assert_false (g_unichar_iszerowidth (0x200A));
1084 : 1 : g_assert_true (g_unichar_iszerowidth (0x200B));
1085 : 1 : g_assert_true (g_unichar_iszerowidth (0x200C));
1086 : 1 : g_assert_true (g_unichar_iszerowidth (0x591));
1087 : :
1088 : : /*** Testing TYPE() border cases ***/
1089 : 1 : g_assert_false (g_unichar_iszerowidth (0x3FF5));
1090 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
1091 : 1 : g_assert_false (g_unichar_iszerowidth (0xFFEFF));
1092 : : /* U+E0001 Language Tag */
1093 : 1 : g_assert_true (g_unichar_iszerowidth (0xE0001));
1094 : 1 : g_assert_false (g_unichar_iszerowidth (G_UNICODE_LAST_CHAR));
1095 : 1 : g_assert_false (g_unichar_iszerowidth (G_UNICODE_LAST_CHAR + 1));
1096 : 1 : g_assert_false (g_unichar_iszerowidth (G_UNICODE_LAST_CHAR_PART1));
1097 : 1 : g_assert_false (g_unichar_iszerowidth (G_UNICODE_LAST_CHAR_PART1 + 1));
1098 : :
1099 : : /* Hangul Jamo Extended-B block, containing jungseong and jongseong for
1100 : : * Old Korean */
1101 : 1 : g_assert_true (g_unichar_iszerowidth (0xD7B0));
1102 : 1 : g_assert_true (g_unichar_iszerowidth (0xD7FB));
1103 : 1 : }
1104 : :
1105 : : /* Test that g_unichar_istitle() returns the correct value for various
1106 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
1107 : : static void
1108 : 1 : test_title (void)
1109 : : {
1110 : 1 : g_assert_true (g_unichar_istitle (0x01c5));
1111 : 1 : g_assert_true (g_unichar_istitle (0x1f88));
1112 : 1 : g_assert_true (g_unichar_istitle (0x1fcc));
1113 : 1 : g_assert_false (g_unichar_istitle ('a'));
1114 : 1 : g_assert_false (g_unichar_istitle ('A'));
1115 : 1 : g_assert_false (g_unichar_istitle (';'));
1116 : :
1117 : : /*** Testing TYPE() border cases ***/
1118 : 1 : g_assert_false (g_unichar_istitle (0x3FF5));
1119 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
1120 : 1 : g_assert_false (g_unichar_istitle (0xFFEFF));
1121 : : /* U+E0001 Language Tag */
1122 : 1 : g_assert_false (g_unichar_istitle (0xE0001));
1123 : 1 : g_assert_false (g_unichar_istitle (G_UNICODE_LAST_CHAR));
1124 : 1 : g_assert_false (g_unichar_istitle (G_UNICODE_LAST_CHAR + 1));
1125 : 1 : g_assert_false (g_unichar_istitle (G_UNICODE_LAST_CHAR_PART1));
1126 : 1 : g_assert_false (g_unichar_istitle (G_UNICODE_LAST_CHAR_PART1 + 1));
1127 : :
1128 : 1 : g_assert_cmphex (g_unichar_totitle (0x0000), ==, 0x0000);
1129 : 1 : g_assert_cmphex (g_unichar_totitle (0x01c6), ==, 0x01c5);
1130 : 1 : g_assert_cmphex (g_unichar_totitle (0x01c4), ==, 0x01c5);
1131 : 1 : g_assert_cmphex (g_unichar_totitle (0x01c5), ==, 0x01c5);
1132 : 1 : g_assert_cmphex (g_unichar_totitle (0x1f80), ==, 0x1f88);
1133 : 1 : g_assert_cmphex (g_unichar_totitle (0x1f88), ==, 0x1f88);
1134 : 1 : g_assert_cmphex (g_unichar_totitle ('a'), ==, 'A');
1135 : 1 : g_assert_cmphex (g_unichar_totitle ('A'), ==, 'A');
1136 : :
1137 : : /*** Testing TYPE() border cases ***/
1138 : 1 : g_assert_cmphex (g_unichar_totitle (0x3FF5), ==, 0x3FF5);
1139 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
1140 : 1 : g_assert_cmphex (g_unichar_totitle (0xFFEFF), ==, 0xFFEFF);
1141 : 1 : g_assert_cmphex (g_unichar_totitle (0xDFFFF), ==, 0xDFFFF);
1142 : : /* U+E0001 Language Tag */
1143 : 1 : g_assert_cmphex (g_unichar_totitle (0xE0001), ==, 0xE0001);
1144 : 1 : g_assert_cmphex (g_unichar_totitle (G_UNICODE_LAST_CHAR), ==,
1145 : : G_UNICODE_LAST_CHAR);
1146 : 1 : g_assert_cmphex (g_unichar_totitle (G_UNICODE_LAST_CHAR + 1), ==,
1147 : : (G_UNICODE_LAST_CHAR + 1));
1148 : 1 : g_assert_cmphex (g_unichar_totitle (G_UNICODE_LAST_CHAR_PART1), ==,
1149 : : (G_UNICODE_LAST_CHAR_PART1));
1150 : 1 : g_assert_cmphex (g_unichar_totitle (G_UNICODE_LAST_CHAR_PART1 + 1), ==,
1151 : : (G_UNICODE_LAST_CHAR_PART1 + 1));
1152 : 1 : }
1153 : :
1154 : : /* Test that g_unichar_isupper() returns the correct value for various
1155 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
1156 : : static void
1157 : 1 : test_upper (void)
1158 : : {
1159 : 1 : g_assert_false (g_unichar_isupper (' '));
1160 : 1 : g_assert_false (g_unichar_isupper ('0'));
1161 : 1 : g_assert_false (g_unichar_isupper ('a'));
1162 : 1 : g_assert_true (g_unichar_isupper ('A'));
1163 : 1 : g_assert_false (g_unichar_isupper (0xff41)); /* Unicode fullwidth 'a' */
1164 : 1 : g_assert_true (g_unichar_isupper (0xff21)); /* Unicode fullwidth 'A' */
1165 : :
1166 : : /*** Testing TYPE() border cases ***/
1167 : 1 : g_assert_false (g_unichar_isupper (0x3FF5));
1168 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
1169 : 1 : g_assert_false (g_unichar_isupper (0xFFEFF));
1170 : : /* U+E0001 Language Tag */
1171 : 1 : g_assert_false (g_unichar_isupper (0xE0001));
1172 : 1 : g_assert_false (g_unichar_isupper (G_UNICODE_LAST_CHAR));
1173 : 1 : g_assert_false (g_unichar_isupper (G_UNICODE_LAST_CHAR + 1));
1174 : 1 : g_assert_false (g_unichar_isupper (G_UNICODE_LAST_CHAR_PART1));
1175 : 1 : g_assert_false (g_unichar_isupper (G_UNICODE_LAST_CHAR_PART1 + 1));
1176 : 1 : }
1177 : :
1178 : : /* Test that g_unichar_islower() returns the correct value for various
1179 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
1180 : : static void
1181 : 1 : test_lower (void)
1182 : : {
1183 : 1 : g_assert_false (g_unichar_islower (' '));
1184 : 1 : g_assert_false (g_unichar_islower ('0'));
1185 : 1 : g_assert_true (g_unichar_islower ('a'));
1186 : 1 : g_assert_false (g_unichar_islower ('A'));
1187 : 1 : g_assert_true (g_unichar_islower (0xff41)); /* Unicode fullwidth 'a' */
1188 : 1 : g_assert_false (g_unichar_islower (0xff21)); /* Unicode fullwidth 'A' */
1189 : :
1190 : : /*** Testing TYPE() border cases ***/
1191 : 1 : g_assert_false (g_unichar_islower (0x3FF5));
1192 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
1193 : 1 : g_assert_false (g_unichar_islower (0xFFEFF));
1194 : : /* U+E0001 Language Tag */
1195 : 1 : g_assert_false (g_unichar_islower (0xE0001));
1196 : 1 : g_assert_false (g_unichar_islower (G_UNICODE_LAST_CHAR));
1197 : 1 : g_assert_false (g_unichar_islower (G_UNICODE_LAST_CHAR + 1));
1198 : 1 : g_assert_false (g_unichar_islower (G_UNICODE_LAST_CHAR_PART1));
1199 : 1 : g_assert_false (g_unichar_islower (G_UNICODE_LAST_CHAR_PART1 + 1));
1200 : 1 : }
1201 : :
1202 : : /* Test that g_unichar_isprint() returns the correct value for various
1203 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
1204 : : static void
1205 : 1 : test_print (void)
1206 : : {
1207 : 1 : g_assert_true (g_unichar_isprint (' '));
1208 : 1 : g_assert_true (g_unichar_isprint ('0'));
1209 : 1 : g_assert_true (g_unichar_isprint ('a'));
1210 : 1 : g_assert_true (g_unichar_isprint ('A'));
1211 : 1 : g_assert_true (g_unichar_isprint (0xff41)); /* Unicode fullwidth 'a' */
1212 : 1 : g_assert_true (g_unichar_isprint (0xff21)); /* Unicode fullwidth 'A' */
1213 : :
1214 : : /*** Testing TYPE() border cases ***/
1215 : 1 : g_assert_true (g_unichar_isprint (0x3FF5));
1216 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
1217 : 1 : g_assert_true (g_unichar_isprint (0xFFEFF));
1218 : : /* U+E0001 Language Tag */
1219 : 1 : g_assert_false (g_unichar_isprint (0xE0001));
1220 : 1 : g_assert_false (g_unichar_isprint (G_UNICODE_LAST_CHAR));
1221 : 1 : g_assert_false (g_unichar_isprint (G_UNICODE_LAST_CHAR + 1));
1222 : 1 : g_assert_false (g_unichar_isprint (G_UNICODE_LAST_CHAR_PART1));
1223 : 1 : g_assert_false (g_unichar_isprint (G_UNICODE_LAST_CHAR_PART1 + 1));
1224 : 1 : }
1225 : :
1226 : : /* Test that g_unichar_toupper() and g_unichar_tolower() return the
1227 : : * correct values for various ASCII and Unicode alphabetic, numeric,
1228 : : * and other, codepoints. */
1229 : : static void
1230 : 1 : test_cases (void)
1231 : : {
1232 : 1 : g_assert_cmphex (g_unichar_toupper (0x0), ==, 0x0);
1233 : 1 : g_assert_cmphex (g_unichar_tolower (0x0), ==, 0x0);
1234 : 1 : g_assert_cmphex (g_unichar_toupper ('a'), ==, 'A');
1235 : 1 : g_assert_cmphex (g_unichar_toupper ('A'), ==, 'A');
1236 : : /* Unicode fullwidth 'a' == 'A' */
1237 : 1 : g_assert_cmphex (g_unichar_toupper (0xff41), ==, 0xff21);
1238 : : /* Unicode fullwidth 'A' == 'A' */
1239 : 1 : g_assert_cmphex (g_unichar_toupper (0xff21), ==, 0xff21);
1240 : 1 : g_assert_cmphex (g_unichar_toupper (0x01C5), ==, 0x01C4);
1241 : 1 : g_assert_cmphex (g_unichar_toupper (0x01C6), ==, 0x01C4);
1242 : 1 : g_assert_cmphex (g_unichar_tolower ('A'), ==, 'a');
1243 : 1 : g_assert_cmphex (g_unichar_tolower ('a'), ==, 'a');
1244 : : /* Unicode fullwidth 'A' == 'a' */
1245 : 1 : g_assert_cmphex (g_unichar_tolower (0xff21), ==, 0xff41);
1246 : : /* Unicode fullwidth 'a' == 'a' */
1247 : 1 : g_assert_cmphex (g_unichar_tolower (0xff41), ==, 0xff41);
1248 : 1 : g_assert_cmphex (g_unichar_tolower (0x01C4), ==, 0x01C6);
1249 : 1 : g_assert_cmphex (g_unichar_tolower (0x01C5), ==, 0x01C6);
1250 : 1 : g_assert_cmphex (g_unichar_tolower (0x1F8A), ==, 0x1F82);
1251 : 1 : g_assert_cmphex (g_unichar_totitle (0x1F8A), ==, 0x1F8A);
1252 : 1 : g_assert_cmphex (g_unichar_toupper (0x1F8A), ==, 0x1F8A);
1253 : 1 : g_assert_cmphex (g_unichar_tolower (0x1FB2), ==, 0x1FB2);
1254 : 1 : g_assert_cmphex (g_unichar_toupper (0x1FB2), ==, 0x1FB2);
1255 : :
1256 : : /* U+130 is a special case, it's a 'I' with a dot on top */
1257 : 1 : g_assert_cmphex (g_unichar_tolower (0x130), ==, 0x69);
1258 : :
1259 : : /* Testing ATTTABLE() border cases */
1260 : 1 : g_assert_cmphex (g_unichar_toupper (0x1D6FE), ==, 0x1D6FE);
1261 : :
1262 : : /*** Testing TYPE() border cases ***/
1263 : 1 : g_assert_cmphex (g_unichar_toupper (0x3FF5), ==, 0x3FF5);
1264 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
1265 : 1 : g_assert_cmphex (g_unichar_toupper (0xFFEFF), ==, 0xFFEFF);
1266 : 1 : g_assert_cmphex (g_unichar_toupper (0xDFFFF), ==, 0xDFFFF);
1267 : : /* U+E0001 Language Tag */
1268 : 1 : g_assert_cmphex (g_unichar_toupper (0xE0001), ==, 0xE0001);
1269 : 1 : g_assert_cmphex (g_unichar_toupper (G_UNICODE_LAST_CHAR), ==,
1270 : : G_UNICODE_LAST_CHAR);
1271 : 1 : g_assert_cmphex (g_unichar_toupper (G_UNICODE_LAST_CHAR + 1), ==,
1272 : : (G_UNICODE_LAST_CHAR + 1));
1273 : 1 : g_assert_cmphex (g_unichar_toupper (G_UNICODE_LAST_CHAR_PART1), ==,
1274 : : (G_UNICODE_LAST_CHAR_PART1));
1275 : 1 : g_assert_cmphex (g_unichar_toupper (G_UNICODE_LAST_CHAR_PART1 + 1), ==,
1276 : : (G_UNICODE_LAST_CHAR_PART1 + 1));
1277 : :
1278 : : /* Testing ATTTABLE() border cases */
1279 : 1 : g_assert_cmphex (g_unichar_tolower (0x1D6FA), ==, 0x1D6FA);
1280 : :
1281 : : /*** Testing TYPE() border cases ***/
1282 : 1 : g_assert_cmphex (g_unichar_tolower (0x3FF5), ==, 0x3FF5);
1283 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
1284 : 1 : g_assert_cmphex (g_unichar_tolower (0xFFEFF), ==, 0xFFEFF);
1285 : 1 : g_assert_cmphex (g_unichar_tolower (0xDFFFF), ==, 0xDFFFF);
1286 : : /* U+E0001 Language Tag */
1287 : 1 : g_assert_cmphex (g_unichar_tolower (0xE0001), ==, 0xE0001);
1288 : 1 : g_assert_cmphex (g_unichar_tolower (G_UNICODE_LAST_CHAR), ==,
1289 : : G_UNICODE_LAST_CHAR);
1290 : 1 : g_assert_cmphex (g_unichar_tolower (G_UNICODE_LAST_CHAR + 1), ==,
1291 : : (G_UNICODE_LAST_CHAR + 1));
1292 : 1 : g_assert_cmphex (g_unichar_tolower (G_UNICODE_LAST_CHAR_PART1), ==,
1293 : : G_UNICODE_LAST_CHAR_PART1);
1294 : 1 : g_assert_cmphex (g_unichar_tolower (G_UNICODE_LAST_CHAR_PART1 + 1), ==,
1295 : : (G_UNICODE_LAST_CHAR_PART1 + 1));
1296 : 1 : }
1297 : :
1298 : : /* Test that g_unichar_isdefined() returns the correct value for various
1299 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
1300 : : static void
1301 : 1 : test_defined (void)
1302 : : {
1303 : 1 : g_assert_true (g_unichar_isdefined (0x0903));
1304 : 1 : g_assert_true (g_unichar_isdefined (0x20DD));
1305 : 1 : g_assert_true (g_unichar_isdefined (0x20BA));
1306 : 1 : g_assert_true (g_unichar_isdefined (0xA806));
1307 : 1 : g_assert_true (g_unichar_isdefined ('a'));
1308 : 1 : g_assert_false (g_unichar_isdefined (0x10C49));
1309 : 1 : g_assert_false (g_unichar_isdefined (0x169D));
1310 : :
1311 : : /*** Testing TYPE() border cases ***/
1312 : 1 : g_assert_true (g_unichar_isdefined (0x3FF5));
1313 : : /* U+FFEFF Plane 15 Private Use (needed to be > G_UNICODE_MAX_TABLE_INDEX) */
1314 : 1 : g_assert_true (g_unichar_isdefined (0xFFEFF));
1315 : 1 : g_assert_false (g_unichar_isdefined (0xDFFFF));
1316 : : /* U+E0001 Language Tag */
1317 : 1 : g_assert_true (g_unichar_isdefined (0xE0001));
1318 : 1 : g_assert_false (g_unichar_isdefined (G_UNICODE_LAST_CHAR));
1319 : 1 : g_assert_false (g_unichar_isdefined (G_UNICODE_LAST_CHAR + 1));
1320 : 1 : g_assert_false (g_unichar_isdefined (G_UNICODE_LAST_CHAR_PART1));
1321 : 1 : g_assert_false (g_unichar_isdefined (G_UNICODE_LAST_CHAR_PART1 + 1));
1322 : 1 : }
1323 : :
1324 : : /* Test that g_unichar_iswide() returns the correct value for various
1325 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
1326 : : static void
1327 : 1 : test_wide (void)
1328 : : {
1329 : : guint i;
1330 : : struct {
1331 : : gunichar c;
1332 : : enum {
1333 : : NOT_WIDE,
1334 : : WIDE_CJK,
1335 : : WIDE
1336 : : } wide;
1337 : 1 : } examples[] = {
1338 : : /* Neutral */
1339 : : { 0x0000, NOT_WIDE },
1340 : : { 0x0483, NOT_WIDE },
1341 : : { 0x0641, NOT_WIDE },
1342 : : { 0xFFFC, NOT_WIDE },
1343 : : { 0x10000, NOT_WIDE },
1344 : : { 0xE0001, NOT_WIDE },
1345 : : { 0x2FFFE, NOT_WIDE },
1346 : : { 0x3FFFE, NOT_WIDE },
1347 : :
1348 : : /* Narrow */
1349 : : { 0x0020, NOT_WIDE },
1350 : : { 0x0041, NOT_WIDE },
1351 : : { 0x27E6, NOT_WIDE },
1352 : :
1353 : : /* Halfwidth */
1354 : : { 0x20A9, NOT_WIDE },
1355 : : { 0xFF61, NOT_WIDE },
1356 : : { 0xFF69, NOT_WIDE },
1357 : : { 0xFFEE, NOT_WIDE },
1358 : :
1359 : : /* Ambiguous */
1360 : : { 0x00A1, WIDE_CJK },
1361 : : { 0x00BE, WIDE_CJK },
1362 : : { 0x02DD, WIDE_CJK },
1363 : : { 0x2020, WIDE_CJK },
1364 : : { 0xFFFD, WIDE_CJK },
1365 : : { 0x00A1, WIDE_CJK },
1366 : : { 0x1F100, WIDE_CJK },
1367 : : { 0xE0100, WIDE_CJK },
1368 : : { 0x100000, WIDE_CJK },
1369 : : { 0x10FFFD, WIDE_CJK },
1370 : :
1371 : : /* Fullwidth */
1372 : : { 0x3000, WIDE },
1373 : : { 0xFF60, WIDE },
1374 : :
1375 : : /* Wide */
1376 : : { 0x2329, WIDE },
1377 : : { 0x3001, WIDE },
1378 : : { 0xFE69, WIDE },
1379 : : { 0x30000, WIDE },
1380 : : { 0x3FFFD, WIDE },
1381 : :
1382 : : /* Default Wide blocks */
1383 : : { 0x4DBF, WIDE },
1384 : : { 0x9FFF, WIDE },
1385 : : { 0xFAFF, WIDE },
1386 : : { 0x2A6DF, WIDE },
1387 : : { 0x2B73F, WIDE },
1388 : : { 0x2B81F, WIDE },
1389 : : { 0x2FA1F, WIDE },
1390 : :
1391 : : /* Uniode-5.2 character additions */
1392 : : /* Wide */
1393 : : { 0x115F, WIDE },
1394 : :
1395 : : /* Uniode-6.0 character additions */
1396 : : /* Wide */
1397 : : { 0x2B740, WIDE },
1398 : : { 0x1B000, WIDE },
1399 : :
1400 : : { 0x111111, NOT_WIDE }
1401 : : };
1402 : :
1403 [ + + ]: 44 : for (i = 0; i < G_N_ELEMENTS (examples); i++)
1404 : : {
1405 : 43 : g_assert_cmpint (g_unichar_iswide (examples[i].c), ==,
1406 : : (examples[i].wide == WIDE));
1407 : 43 : g_assert_cmpint (g_unichar_iswide_cjk (examples[i].c), ==,
1408 : : (examples[i].wide != NOT_WIDE));
1409 : : }
1410 : 1 : };
1411 : :
1412 : : /* Test that g_unichar_compose() returns the correct value for various
1413 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
1414 : : static void
1415 : 1 : test_compose (void)
1416 : : {
1417 : : gunichar ch;
1418 : :
1419 : : /* Not composable */
1420 : 1 : g_assert_false (g_unichar_compose (0x0041, 0x0042, &ch) && ch == 0);
1421 : 1 : g_assert_false (g_unichar_compose (0x0041, 0, &ch) && ch == 0);
1422 : 1 : g_assert_false (g_unichar_compose (0x0066, 0x0069, &ch) && ch == 0);
1423 : :
1424 : : /* Tricky non-composable */
1425 : 1 : g_assert_false (g_unichar_compose (0x0308, 0x0301, &ch) && ch == 0); /* !0x0344 */
1426 : 1 : g_assert_false (g_unichar_compose (0x0F71, 0x0F72, &ch) && ch == 0); /* !0x0F73 */
1427 : :
1428 : : /* Singletons should not compose */
1429 : 1 : g_assert_false (g_unichar_compose (0x212B, 0, &ch) && ch == 0);
1430 : 1 : g_assert_false (g_unichar_compose (0x00C5, 0, &ch) && ch == 0);
1431 : 1 : g_assert_false (g_unichar_compose (0x2126, 0, &ch) && ch == 0);
1432 : 1 : g_assert_false (g_unichar_compose (0x03A9, 0, &ch) && ch == 0);
1433 : :
1434 : : /* Pairs */
1435 : 1 : g_assert_true (g_unichar_compose (0x0041, 0x030A, &ch) && ch == 0x00C5);
1436 : 1 : g_assert_true (g_unichar_compose (0x006F, 0x0302, &ch) && ch == 0x00F4);
1437 : 1 : g_assert_true (g_unichar_compose (0x1E63, 0x0307, &ch) && ch == 0x1E69);
1438 : 1 : g_assert_true (g_unichar_compose (0x0073, 0x0323, &ch) && ch == 0x1E63);
1439 : 1 : g_assert_true (g_unichar_compose (0x0064, 0x0307, &ch) && ch == 0x1E0B);
1440 : 1 : g_assert_true (g_unichar_compose (0x0064, 0x0323, &ch) && ch == 0x1E0D);
1441 : :
1442 : : /* Hangul */
1443 : 1 : g_assert_true (g_unichar_compose (0xD4CC, 0x11B6, &ch) && ch == 0xD4DB);
1444 : 1 : g_assert_true (g_unichar_compose (0x1111, 0x1171, &ch) && ch == 0xD4CC);
1445 : 1 : g_assert_true (g_unichar_compose (0xCE20, 0x11B8, &ch) && ch == 0xCE31);
1446 : 1 : g_assert_true (g_unichar_compose (0x110E, 0x1173, &ch) && ch == 0xCE20);
1447 : 1 : }
1448 : :
1449 : : /* Test that g_unichar_decompose() returns the correct value for various
1450 : : * ASCII and Unicode alphabetic, numeric, and other, codepoints. */
1451 : : static void
1452 : 1 : test_decompose (void)
1453 : : {
1454 : : gunichar a, b;
1455 : :
1456 : : /* Not decomposable */
1457 : 1 : g_assert_false (g_unichar_decompose (0x0041, &a, &b) && a == 0x0041 && b == 0);
1458 : 1 : g_assert_false (g_unichar_decompose (0xFB01, &a, &b) && a == 0xFB01 && b == 0);
1459 : :
1460 : : /* Singletons */
1461 : 1 : g_assert_true (g_unichar_decompose (0x212B, &a, &b) && a == 0x00C5 && b == 0);
1462 : 1 : g_assert_true (g_unichar_decompose (0x2126, &a, &b) && a == 0x03A9 && b == 0);
1463 : :
1464 : : /* Tricky pairs */
1465 : 1 : g_assert_true (g_unichar_decompose (0x0344, &a, &b) && a == 0x0308 && b == 0x0301);
1466 : 1 : g_assert_true (g_unichar_decompose (0x0F73, &a, &b) && a == 0x0F71 && b == 0x0F72);
1467 : :
1468 : : /* Pairs */
1469 : 1 : g_assert_true (g_unichar_decompose (0x00C5, &a, &b) && a == 0x0041 && b == 0x030A);
1470 : 1 : g_assert_true (g_unichar_decompose (0x00F4, &a, &b) && a == 0x006F && b == 0x0302);
1471 : 1 : g_assert_true (g_unichar_decompose (0x1E69, &a, &b) && a == 0x1E63 && b == 0x0307);
1472 : 1 : g_assert_true (g_unichar_decompose (0x1E63, &a, &b) && a == 0x0073 && b == 0x0323);
1473 : 1 : g_assert_true (g_unichar_decompose (0x1E0B, &a, &b) && a == 0x0064 && b == 0x0307);
1474 : 1 : g_assert_true (g_unichar_decompose (0x1E0D, &a, &b) && a == 0x0064 && b == 0x0323);
1475 : :
1476 : : /* Hangul */
1477 : 1 : g_assert_true (g_unichar_decompose (0xD4DB, &a, &b) && a == 0xD4CC && b == 0x11B6);
1478 : 1 : g_assert_true (g_unichar_decompose (0xD4CC, &a, &b) && a == 0x1111 && b == 0x1171);
1479 : 1 : g_assert_true (g_unichar_decompose (0xCE31, &a, &b) && a == 0xCE20 && b == 0x11B8);
1480 : 1 : g_assert_true (g_unichar_decompose (0xCE20, &a, &b) && a == 0x110E && b == 0x1173);
1481 : 1 : }
1482 : :
1483 : : /* Test that g_unichar_fully_decompose() returns the correct value for
1484 : : * various ASCII and Unicode alphabetic, numeric, and other, codepoints. */
1485 : : static void
1486 : 1 : test_fully_decompose_canonical (void)
1487 : : {
1488 : : gunichar decomp[5];
1489 : : gsize len;
1490 : :
1491 : : #define TEST_DECOMP(ch, expected_len, a, b, c, d) \
1492 : : len = g_unichar_fully_decompose (ch, FALSE, decomp, G_N_ELEMENTS (decomp)); \
1493 : : g_assert_cmpint (expected_len, ==, len); \
1494 : : if (expected_len >= 1) g_assert_cmphex (decomp[0], ==, a); \
1495 : : if (expected_len >= 2) g_assert_cmphex (decomp[1], ==, b); \
1496 : : if (expected_len >= 3) g_assert_cmphex (decomp[2], ==, c); \
1497 : : if (expected_len >= 4) g_assert_cmphex (decomp[3], ==, d); \
1498 : :
1499 : : #define TEST0(ch) TEST_DECOMP (ch, 1, ch, 0, 0, 0)
1500 : : #define TEST1(ch, a) TEST_DECOMP (ch, 1, a, 0, 0, 0)
1501 : : #define TEST2(ch, a, b) TEST_DECOMP (ch, 2, a, b, 0, 0)
1502 : : #define TEST3(ch, a, b, c) TEST_DECOMP (ch, 3, a, b, c, 0)
1503 : : #define TEST4(ch, a, b, c, d) TEST_DECOMP (ch, 4, a, b, c, d)
1504 : :
1505 : : /* Not decomposable */
1506 [ - + - + ]: 1 : TEST0 (0x0041);
1507 [ - + - + ]: 1 : TEST0 (0xFB01);
1508 : :
1509 : : /* Singletons */
1510 [ - + - + : 1 : TEST2 (0x212B, 0x0041, 0x030A);
- + ]
1511 [ - + - + ]: 1 : TEST1 (0x2126, 0x03A9);
1512 : :
1513 : : /* Tricky pairs */
1514 [ - + - + : 1 : TEST2 (0x0344, 0x0308, 0x0301);
- + ]
1515 [ - + - + : 1 : TEST2 (0x0F73, 0x0F71, 0x0F72);
- + ]
1516 : :
1517 : : /* General */
1518 [ - + - + : 1 : TEST2 (0x00C5, 0x0041, 0x030A);
- + ]
1519 [ - + - + : 1 : TEST2 (0x00F4, 0x006F, 0x0302);
- + ]
1520 [ - + - + : 1 : TEST3 (0x1E69, 0x0073, 0x0323, 0x0307);
- + - + ]
1521 [ - + - + : 1 : TEST2 (0x1E63, 0x0073, 0x0323);
- + ]
1522 [ - + - + : 1 : TEST2 (0x1E0B, 0x0064, 0x0307);
- + ]
1523 [ - + - + : 1 : TEST2 (0x1E0D, 0x0064, 0x0323);
- + ]
1524 : :
1525 : : /* Hangul */
1526 [ - + - + : 1 : TEST3 (0xD4DB, 0x1111, 0x1171, 0x11B6);
- + - + ]
1527 [ - + - + : 1 : TEST2 (0xD4CC, 0x1111, 0x1171);
- + ]
1528 [ - + - + : 1 : TEST3 (0xCE31, 0x110E, 0x1173, 0x11B8);
- + - + ]
1529 [ - + - + : 1 : TEST2 (0xCE20, 0x110E, 0x1173);
- + ]
1530 : :
1531 : : #undef TEST_DECOMP
1532 : 1 : }
1533 : :
1534 : : /* Test that g_unicode_canonical_decomposition() returns the correct
1535 : : * value for various ASCII and Unicode alphabetic, numeric, and other,
1536 : : * codepoints. */
1537 : : static void
1538 : 1 : test_canonical_decomposition (void)
1539 : : {
1540 : : gunichar *decomp;
1541 : : gsize len;
1542 : :
1543 : : #define TEST_DECOMP(ch, expected_len, a, b, c, d) \
1544 : : decomp = g_unicode_canonical_decomposition (ch, &len); \
1545 : : g_assert_cmpint (expected_len, ==, len); \
1546 : : if (expected_len >= 1) g_assert_cmphex (decomp[0], ==, a); \
1547 : : if (expected_len >= 2) g_assert_cmphex (decomp[1], ==, b); \
1548 : : if (expected_len >= 3) g_assert_cmphex (decomp[2], ==, c); \
1549 : : if (expected_len >= 4) g_assert_cmphex (decomp[3], ==, d); \
1550 : : g_free (decomp);
1551 : :
1552 : : #define TEST0(ch) TEST_DECOMP (ch, 1, ch, 0, 0, 0)
1553 : : #define TEST1(ch, a) TEST_DECOMP (ch, 1, a, 0, 0, 0)
1554 : : #define TEST2(ch, a, b) TEST_DECOMP (ch, 2, a, b, 0, 0)
1555 : : #define TEST3(ch, a, b, c) TEST_DECOMP (ch, 3, a, b, c, 0)
1556 : : #define TEST4(ch, a, b, c, d) TEST_DECOMP (ch, 4, a, b, c, d)
1557 : :
1558 : : /* Not decomposable */
1559 [ - + - + ]: 1 : TEST0 (0x0041);
1560 [ - + - + ]: 1 : TEST0 (0xFB01);
1561 : :
1562 : : /* Singletons */
1563 [ - + - + : 1 : TEST2 (0x212B, 0x0041, 0x030A);
- + ]
1564 [ - + - + ]: 1 : TEST1 (0x2126, 0x03A9);
1565 : :
1566 : : /* Tricky pairs */
1567 [ - + - + : 1 : TEST2 (0x0344, 0x0308, 0x0301);
- + ]
1568 [ - + - + : 1 : TEST2 (0x0F73, 0x0F71, 0x0F72);
- + ]
1569 : :
1570 : : /* General */
1571 [ - + - + : 1 : TEST2 (0x00C5, 0x0041, 0x030A);
- + ]
1572 [ - + - + : 1 : TEST2 (0x00F4, 0x006F, 0x0302);
- + ]
1573 [ - + - + : 1 : TEST3 (0x1E69, 0x0073, 0x0323, 0x0307);
- + - + ]
1574 [ - + - + : 1 : TEST2 (0x1E63, 0x0073, 0x0323);
- + ]
1575 [ - + - + : 1 : TEST2 (0x1E0B, 0x0064, 0x0307);
- + ]
1576 [ - + - + : 1 : TEST2 (0x1E0D, 0x0064, 0x0323);
- + ]
1577 : :
1578 : : /* Hangul */
1579 [ - + - + : 1 : TEST3 (0xD4DB, 0x1111, 0x1171, 0x11B6);
- + - + ]
1580 [ - + - + : 1 : TEST2 (0xD4CC, 0x1111, 0x1171);
- + ]
1581 [ - + - + : 1 : TEST3 (0xCE31, 0x110E, 0x1173, 0x11B8);
- + - + ]
1582 [ - + - + : 1 : TEST2 (0xCE20, 0x110E, 0x1173);
- + ]
1583 : :
1584 : : #undef TEST_DECOMP
1585 : 1 : }
1586 : :
1587 : : /* Test that g_unichar_decompose() whenever encouttering a char ch
1588 : : * decomposes into a and b, b itself won't decompose any further. */
1589 : : static void
1590 : 1 : test_decompose_tail (void)
1591 : : {
1592 : : gunichar ch, a, b, c, d;
1593 : :
1594 : : /* Test that whenever a char ch decomposes into a and b, b itself
1595 : : * won't decompose any further. */
1596 : :
1597 [ + + ]: 1114113 : for (ch = 0; ch < 0x110000; ch++)
1598 [ + + ]: 1114112 : if (g_unichar_decompose (ch, &a, &b))
1599 : 13233 : g_assert_false (g_unichar_decompose (b, &c, &d));
1600 : : else
1601 : : {
1602 : 1100879 : g_assert_cmpuint (a, ==, ch);
1603 : 1100879 : g_assert_cmpuint (b, ==, 0);
1604 : : }
1605 : 1 : }
1606 : :
1607 : : /* Test that all canonical decompositions of g_unichar_fully_decompose()
1608 : : * are at most 4 in length, and compatibility decompositions are
1609 : : * at most 18 in length. */
1610 : : static void
1611 : 1 : test_fully_decompose_len (void)
1612 : : {
1613 : : gunichar ch;
1614 : :
1615 : : /* Test that all canonical decompositions are at most 4 in length,
1616 : : * and compatibility decompositions are at most 18 in length.
1617 : : */
1618 : :
1619 [ + + ]: 1114113 : for (ch = 0; ch < 0x110000; ch++) {
1620 : 1114112 : g_assert_cmpint (g_unichar_fully_decompose (ch, FALSE, NULL, 0), <=, 4);
1621 : 1114112 : g_assert_cmpint (g_unichar_fully_decompose (ch, TRUE, NULL, 0), <=, 18);
1622 : : }
1623 : 1 : }
1624 : :
1625 : : /* Check various examples from Unicode Annex #15 for NFD and NFC
1626 : : * normalization.
1627 : : */
1628 : : static void
1629 : 1 : test_normalization (void)
1630 : : {
1631 : : const struct {
1632 : : const char *source;
1633 : : const char *nfd;
1634 : : const char *nfc;
1635 : 1 : } tests[] = {
1636 : : // Singletons
1637 : : { "\xe2\x84\xab", "A\xcc\x8a", "Å" }, // U+212B ANGSTROM SIGN
1638 : : { "\xe2\x84\xa6", "Ω", "Ω" }, // U+2126 OHM SIGN
1639 : : // Canonical Composites
1640 : : { "Å", "A\xcc\x8a", "Å" }, // U+00C5 LATIN CAPITAL LETTER A WITH RING ABOVE
1641 : : { "ô", "o\xcc\x82", "ô" }, // U+00F4 LATIN SMALL LETTER O WITH CIRCUMFLEX
1642 : : // Multiple Combining Marks
1643 : : { "\xe1\xb9\xa9", "s\xcc\xa3\xcc\x87", "ṩ" }, // U+1E69 LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE
1644 : : { "\xe1\xb8\x8b\xcc\xa3", "d\xcc\xa3\xcc\x87", "ḍ̇" },
1645 : : { "q\xcc\x87\xcc\xa3", "q\xcc\xa3\xcc\x87", "q̣̇" },
1646 : : // Compatibility Composites
1647 : : { "fi", "fi", "fi" }, // U+FB01 LATIN SMALL LIGATURE FI
1648 : : { "2\xe2\x81\xb5", "2\xe2\x81\xb5", "2⁵" },
1649 : : { "\xe1\xba\x9b\xcc\xa3", "\xc5\xbf\xcc\xa3\xcc\x87", "ẛ̣" },
1650 : :
1651 : : // Tests for behavior with reordered marks
1652 : : { "s\xcc\x87\xcc\xa3", "s\xcc\xa3\xcc\x87", "ṩ" },
1653 : : { "α\xcc\x94\xcd\x82", "α\xcc\x94\xcd\x82", "ἇ" },
1654 : : { "α\xcd\x82\xcc\x94", "α\xcd\x82\xcc\x94", "ᾶ\xcc\x94" },
1655 : : };
1656 : : gsize i;
1657 : :
1658 [ + + ]: 14 : for (i = 0; i < G_N_ELEMENTS (tests); i++)
1659 : : {
1660 : : char *nfd, *nfc;
1661 : :
1662 : 13 : nfd = g_utf8_normalize (tests[i].source, -1, G_NORMALIZE_NFD);
1663 : 13 : g_assert_cmpstr (nfd, ==, tests[i].nfd);
1664 : :
1665 : 13 : nfc = g_utf8_normalize (tests[i].nfd, -1, G_NORMALIZE_NFC);
1666 : 13 : g_assert_cmpstr (nfc, ==, tests[i].nfc);
1667 : :
1668 : 13 : g_free (nfd);
1669 : 13 : g_free (nfc);
1670 : : }
1671 : 1 : }
1672 : :
1673 : : static void
1674 : 1 : test_iso15924 (void)
1675 : : {
1676 : : const struct {
1677 : : GUnicodeScript script;
1678 : : char four_letter_code[5];
1679 : 1 : } data[] = {
1680 : : { G_UNICODE_SCRIPT_COMMON, "Zyyy" },
1681 : : { G_UNICODE_SCRIPT_INHERITED, "Zinh" },
1682 : : { G_UNICODE_SCRIPT_MATH, "Zmth" },
1683 : : { G_UNICODE_SCRIPT_ARABIC, "Arab" },
1684 : : { G_UNICODE_SCRIPT_ARMENIAN, "Armn" },
1685 : : { G_UNICODE_SCRIPT_BENGALI, "Beng" },
1686 : : { G_UNICODE_SCRIPT_BOPOMOFO, "Bopo" },
1687 : : { G_UNICODE_SCRIPT_CHEROKEE, "Cher" },
1688 : : { G_UNICODE_SCRIPT_COPTIC, "Copt" },
1689 : : { G_UNICODE_SCRIPT_CYRILLIC, "Cyrl" },
1690 : : { G_UNICODE_SCRIPT_DESERET, "Dsrt" },
1691 : : { G_UNICODE_SCRIPT_DEVANAGARI, "Deva" },
1692 : : { G_UNICODE_SCRIPT_ETHIOPIC, "Ethi" },
1693 : : { G_UNICODE_SCRIPT_GEORGIAN, "Geor" },
1694 : : { G_UNICODE_SCRIPT_GOTHIC, "Goth" },
1695 : : { G_UNICODE_SCRIPT_GREEK, "Grek" },
1696 : : { G_UNICODE_SCRIPT_GUJARATI, "Gujr" },
1697 : : { G_UNICODE_SCRIPT_GURMUKHI, "Guru" },
1698 : : { G_UNICODE_SCRIPT_HAN, "Hani" },
1699 : : { G_UNICODE_SCRIPT_HANGUL, "Hang" },
1700 : : { G_UNICODE_SCRIPT_HEBREW, "Hebr" },
1701 : : { G_UNICODE_SCRIPT_HIRAGANA, "Hira" },
1702 : : { G_UNICODE_SCRIPT_KANNADA, "Knda" },
1703 : : { G_UNICODE_SCRIPT_KATAKANA, "Kana" },
1704 : : { G_UNICODE_SCRIPT_KHMER, "Khmr" },
1705 : : { G_UNICODE_SCRIPT_LAO, "Laoo" },
1706 : : { G_UNICODE_SCRIPT_LATIN, "Latn" },
1707 : : { G_UNICODE_SCRIPT_MALAYALAM, "Mlym" },
1708 : : { G_UNICODE_SCRIPT_MONGOLIAN, "Mong" },
1709 : : { G_UNICODE_SCRIPT_MYANMAR, "Mymr" },
1710 : : { G_UNICODE_SCRIPT_OGHAM, "Ogam" },
1711 : : { G_UNICODE_SCRIPT_OLD_ITALIC, "Ital" },
1712 : : { G_UNICODE_SCRIPT_ORIYA, "Orya" },
1713 : : { G_UNICODE_SCRIPT_RUNIC, "Runr" },
1714 : : { G_UNICODE_SCRIPT_SINHALA, "Sinh" },
1715 : : { G_UNICODE_SCRIPT_SYRIAC, "Syrc" },
1716 : : { G_UNICODE_SCRIPT_TAMIL, "Taml" },
1717 : : { G_UNICODE_SCRIPT_TELUGU, "Telu" },
1718 : : { G_UNICODE_SCRIPT_THAANA, "Thaa" },
1719 : : { G_UNICODE_SCRIPT_THAI, "Thai" },
1720 : : { G_UNICODE_SCRIPT_TIBETAN, "Tibt" },
1721 : : { G_UNICODE_SCRIPT_CANADIAN_ABORIGINAL, "Cans" },
1722 : : { G_UNICODE_SCRIPT_YI, "Yiii" },
1723 : : { G_UNICODE_SCRIPT_TAGALOG, "Tglg" },
1724 : : { G_UNICODE_SCRIPT_HANUNOO, "Hano" },
1725 : : { G_UNICODE_SCRIPT_BUHID, "Buhd" },
1726 : : { G_UNICODE_SCRIPT_TAGBANWA, "Tagb" },
1727 : :
1728 : : /* Unicode-4.0 additions */
1729 : : { G_UNICODE_SCRIPT_BRAILLE, "Brai" },
1730 : : { G_UNICODE_SCRIPT_CYPRIOT, "Cprt" },
1731 : : { G_UNICODE_SCRIPT_LIMBU, "Limb" },
1732 : : { G_UNICODE_SCRIPT_OSMANYA, "Osma" },
1733 : : { G_UNICODE_SCRIPT_SHAVIAN, "Shaw" },
1734 : : { G_UNICODE_SCRIPT_LINEAR_B, "Linb" },
1735 : : { G_UNICODE_SCRIPT_TAI_LE, "Tale" },
1736 : : { G_UNICODE_SCRIPT_UGARITIC, "Ugar" },
1737 : :
1738 : : /* Unicode-4.1 additions */
1739 : : { G_UNICODE_SCRIPT_NEW_TAI_LUE, "Talu" },
1740 : : { G_UNICODE_SCRIPT_BUGINESE, "Bugi" },
1741 : : { G_UNICODE_SCRIPT_GLAGOLITIC, "Glag" },
1742 : : { G_UNICODE_SCRIPT_TIFINAGH, "Tfng" },
1743 : : { G_UNICODE_SCRIPT_SYLOTI_NAGRI, "Sylo" },
1744 : : { G_UNICODE_SCRIPT_OLD_PERSIAN, "Xpeo" },
1745 : : { G_UNICODE_SCRIPT_KHAROSHTHI, "Khar" },
1746 : :
1747 : : /* Unicode-5.0 additions */
1748 : : { G_UNICODE_SCRIPT_UNKNOWN, "Zzzz" },
1749 : : { G_UNICODE_SCRIPT_BALINESE, "Bali" },
1750 : : { G_UNICODE_SCRIPT_CUNEIFORM, "Xsux" },
1751 : : { G_UNICODE_SCRIPT_PHOENICIAN, "Phnx" },
1752 : : { G_UNICODE_SCRIPT_PHAGS_PA, "Phag" },
1753 : : { G_UNICODE_SCRIPT_NKO, "Nkoo" },
1754 : :
1755 : : /* Unicode-5.1 additions */
1756 : : { G_UNICODE_SCRIPT_KAYAH_LI, "Kali" },
1757 : : { G_UNICODE_SCRIPT_LEPCHA, "Lepc" },
1758 : : { G_UNICODE_SCRIPT_REJANG, "Rjng" },
1759 : : { G_UNICODE_SCRIPT_SUNDANESE, "Sund" },
1760 : : { G_UNICODE_SCRIPT_SAURASHTRA, "Saur" },
1761 : : { G_UNICODE_SCRIPT_CHAM, "Cham" },
1762 : : { G_UNICODE_SCRIPT_OL_CHIKI, "Olck" },
1763 : : { G_UNICODE_SCRIPT_VAI, "Vaii" },
1764 : : { G_UNICODE_SCRIPT_CARIAN, "Cari" },
1765 : : { G_UNICODE_SCRIPT_LYCIAN, "Lyci" },
1766 : : { G_UNICODE_SCRIPT_LYDIAN, "Lydi" },
1767 : :
1768 : : /* Unicode-5.2 additions */
1769 : : { G_UNICODE_SCRIPT_AVESTAN, "Avst" },
1770 : : { G_UNICODE_SCRIPT_BAMUM, "Bamu" },
1771 : : { G_UNICODE_SCRIPT_EGYPTIAN_HIEROGLYPHS, "Egyp" },
1772 : : { G_UNICODE_SCRIPT_IMPERIAL_ARAMAIC, "Armi" },
1773 : : { G_UNICODE_SCRIPT_INSCRIPTIONAL_PAHLAVI, "Phli" },
1774 : : { G_UNICODE_SCRIPT_INSCRIPTIONAL_PARTHIAN, "Prti" },
1775 : : { G_UNICODE_SCRIPT_JAVANESE, "Java" },
1776 : : { G_UNICODE_SCRIPT_KAITHI, "Kthi" },
1777 : : { G_UNICODE_SCRIPT_LISU, "Lisu" },
1778 : : { G_UNICODE_SCRIPT_MEETEI_MAYEK, "Mtei" },
1779 : : { G_UNICODE_SCRIPT_OLD_SOUTH_ARABIAN, "Sarb" },
1780 : : { G_UNICODE_SCRIPT_OLD_TURKIC, "Orkh" },
1781 : : { G_UNICODE_SCRIPT_SAMARITAN, "Samr" },
1782 : : { G_UNICODE_SCRIPT_TAI_THAM, "Lana" },
1783 : : { G_UNICODE_SCRIPT_TAI_VIET, "Tavt" },
1784 : :
1785 : : /* Unicode-6.0 additions */
1786 : : { G_UNICODE_SCRIPT_BATAK, "Batk" },
1787 : : { G_UNICODE_SCRIPT_BRAHMI, "Brah" },
1788 : : { G_UNICODE_SCRIPT_MANDAIC, "Mand" },
1789 : :
1790 : : /* Unicode-6.1 additions */
1791 : : { G_UNICODE_SCRIPT_CHAKMA, "Cakm" },
1792 : : { G_UNICODE_SCRIPT_MEROITIC_CURSIVE, "Merc" },
1793 : : { G_UNICODE_SCRIPT_MEROITIC_HIEROGLYPHS, "Mero" },
1794 : : { G_UNICODE_SCRIPT_MIAO, "Plrd" },
1795 : : { G_UNICODE_SCRIPT_SHARADA, "Shrd" },
1796 : : { G_UNICODE_SCRIPT_SORA_SOMPENG, "Sora" },
1797 : : { G_UNICODE_SCRIPT_TAKRI, "Takr" },
1798 : :
1799 : : /* Unicode 7.0 additions */
1800 : : { G_UNICODE_SCRIPT_BASSA_VAH, "Bass" },
1801 : : { G_UNICODE_SCRIPT_CAUCASIAN_ALBANIAN, "Aghb" },
1802 : : { G_UNICODE_SCRIPT_DUPLOYAN, "Dupl" },
1803 : : { G_UNICODE_SCRIPT_ELBASAN, "Elba" },
1804 : : { G_UNICODE_SCRIPT_GRANTHA, "Gran" },
1805 : : { G_UNICODE_SCRIPT_KHOJKI, "Khoj" },
1806 : : { G_UNICODE_SCRIPT_KHUDAWADI, "Sind" },
1807 : : { G_UNICODE_SCRIPT_LINEAR_A, "Lina" },
1808 : : { G_UNICODE_SCRIPT_MAHAJANI, "Mahj" },
1809 : : { G_UNICODE_SCRIPT_MANICHAEAN, "Mani" },
1810 : : { G_UNICODE_SCRIPT_MENDE_KIKAKUI, "Mend" },
1811 : : { G_UNICODE_SCRIPT_MODI, "Modi" },
1812 : : { G_UNICODE_SCRIPT_MRO, "Mroo" },
1813 : : { G_UNICODE_SCRIPT_NABATAEAN, "Nbat" },
1814 : : { G_UNICODE_SCRIPT_OLD_NORTH_ARABIAN, "Narb" },
1815 : : { G_UNICODE_SCRIPT_OLD_PERMIC, "Perm" },
1816 : : { G_UNICODE_SCRIPT_PAHAWH_HMONG, "Hmng" },
1817 : : { G_UNICODE_SCRIPT_PALMYRENE, "Palm" },
1818 : : { G_UNICODE_SCRIPT_PAU_CIN_HAU, "Pauc" },
1819 : : { G_UNICODE_SCRIPT_PSALTER_PAHLAVI, "Phlp" },
1820 : : { G_UNICODE_SCRIPT_SIDDHAM, "Sidd" },
1821 : : { G_UNICODE_SCRIPT_TIRHUTA, "Tirh" },
1822 : : { G_UNICODE_SCRIPT_WARANG_CITI, "Wara" },
1823 : :
1824 : : /* Unicode 8.0 additions */
1825 : : { G_UNICODE_SCRIPT_AHOM, "Ahom" },
1826 : : { G_UNICODE_SCRIPT_ANATOLIAN_HIEROGLYPHS, "Hluw" },
1827 : : { G_UNICODE_SCRIPT_HATRAN, "Hatr" },
1828 : : { G_UNICODE_SCRIPT_MULTANI, "Mult" },
1829 : : { G_UNICODE_SCRIPT_OLD_HUNGARIAN, "Hung" },
1830 : : { G_UNICODE_SCRIPT_SIGNWRITING, "Sgnw" },
1831 : :
1832 : : /* Unicode 9.0 additions */
1833 : : { G_UNICODE_SCRIPT_ADLAM, "Adlm" },
1834 : : { G_UNICODE_SCRIPT_BHAIKSUKI, "Bhks" },
1835 : : { G_UNICODE_SCRIPT_MARCHEN, "Marc" },
1836 : : { G_UNICODE_SCRIPT_NEWA, "Newa" },
1837 : : { G_UNICODE_SCRIPT_OSAGE, "Osge" },
1838 : : { G_UNICODE_SCRIPT_TANGUT, "Tang" },
1839 : :
1840 : : /* Unicode 10.0 additions */
1841 : : { G_UNICODE_SCRIPT_MASARAM_GONDI, "Gonm" },
1842 : : { G_UNICODE_SCRIPT_NUSHU, "Nshu" },
1843 : : { G_UNICODE_SCRIPT_SOYOMBO, "Soyo" },
1844 : : { G_UNICODE_SCRIPT_ZANABAZAR_SQUARE, "Zanb" },
1845 : :
1846 : : /* Unicode 11.0 additions */
1847 : : { G_UNICODE_SCRIPT_DOGRA, "Dogr" },
1848 : : { G_UNICODE_SCRIPT_GUNJALA_GONDI, "Gong" },
1849 : : { G_UNICODE_SCRIPT_HANIFI_ROHINGYA, "Rohg" },
1850 : : { G_UNICODE_SCRIPT_MAKASAR, "Maka" },
1851 : : { G_UNICODE_SCRIPT_MEDEFAIDRIN, "Medf" },
1852 : : { G_UNICODE_SCRIPT_OLD_SOGDIAN, "Sogo" },
1853 : : { G_UNICODE_SCRIPT_SOGDIAN, "Sogd" },
1854 : :
1855 : : /* Unicode 12.0 additions */
1856 : : { G_UNICODE_SCRIPT_ELYMAIC, "Elym" },
1857 : : { G_UNICODE_SCRIPT_NANDINAGARI, "Nand" },
1858 : : { G_UNICODE_SCRIPT_NYIAKENG_PUACHUE_HMONG, "Hmnp" },
1859 : : { G_UNICODE_SCRIPT_WANCHO, "Wcho" },
1860 : :
1861 : : /* Unicode 13.0 additions */
1862 : : { G_UNICODE_SCRIPT_CHORASMIAN, "Chrs" },
1863 : : { G_UNICODE_SCRIPT_DIVES_AKURU, "Diak" },
1864 : : { G_UNICODE_SCRIPT_KHITAN_SMALL_SCRIPT, "Kits" },
1865 : : { G_UNICODE_SCRIPT_YEZIDI, "Yezi" },
1866 : :
1867 : : /* Unicode 14.0 additions */
1868 : : { G_UNICODE_SCRIPT_CYPRO_MINOAN, "Cpmn" },
1869 : : { G_UNICODE_SCRIPT_OLD_UYGHUR, "Ougr" },
1870 : : { G_UNICODE_SCRIPT_TANGSA, "Tnsa" },
1871 : : { G_UNICODE_SCRIPT_TOTO, "Toto" },
1872 : : { G_UNICODE_SCRIPT_VITHKUQI, "Vith" },
1873 : :
1874 : : /* Unicode 15.0 additions */
1875 : : { G_UNICODE_SCRIPT_KAWI, "Kawi" },
1876 : : { G_UNICODE_SCRIPT_NAG_MUNDARI, "Nagm" },
1877 : : };
1878 : : guint i;
1879 : :
1880 : 1 : g_assert_cmphex (0, ==,
1881 : : g_unicode_script_to_iso15924 (G_UNICODE_SCRIPT_INVALID_CODE));
1882 : 1 : g_assert_cmphex (0x5A7A7A7A, ==, g_unicode_script_to_iso15924 (1000));
1883 : 1 : g_assert_cmphex (0x41726162, ==,
1884 : : g_unicode_script_to_iso15924 (G_UNICODE_SCRIPT_ARABIC));
1885 : :
1886 : 1 : g_assert_cmphex (G_UNICODE_SCRIPT_INVALID_CODE, ==,
1887 : : g_unicode_script_from_iso15924 (0));
1888 : 1 : g_assert_cmphex (G_UNICODE_SCRIPT_UNKNOWN, ==,
1889 : : g_unicode_script_from_iso15924 (0x12345678));
1890 : :
1891 : : #define PACK(a,b,c,d) \
1892 : : ((guint32)((((guint8)(a))<<24)|(((guint8)(b))<<16)|(((guint8)(c))<<8)|((guint8)(d))))
1893 : :
1894 [ + + ]: 166 : for (i = 0; i < G_N_ELEMENTS (data); i++)
1895 : : {
1896 : 165 : guint32 code = PACK (data[i].four_letter_code[0],
1897 : : data[i].four_letter_code[1],
1898 : : data[i].four_letter_code[2],
1899 : : data[i].four_letter_code[3]);
1900 : :
1901 : 165 : g_test_message ("Testing script %s (code %u)", data[i].four_letter_code, code);
1902 : 165 : g_assert_cmphex (g_unicode_script_to_iso15924 (data[i].script), ==, code);
1903 : 165 : g_assert_cmpint (g_unicode_script_from_iso15924 (code), ==, data[i].script);
1904 : : }
1905 : :
1906 : : #undef PACK
1907 : 1 : }
1908 : :
1909 : : static void
1910 : 1 : test_normalize (void)
1911 : : {
1912 : : guint i;
1913 : : typedef struct
1914 : : {
1915 : : const gchar *str;
1916 : : const gchar *nfd;
1917 : : const gchar *nfc;
1918 : : const gchar *nfkd;
1919 : : const gchar *nfkc;
1920 : : } Test;
1921 : 1 : Test tests[] = {
1922 : : { "Äffin", "A\u0308ffin", "Äffin", "A\u0308ffin", "Äffin" },
1923 : : { "Ä\uFB03n", "A\u0308\uFB03n", "Ä\uFB03n", "A\u0308ffin", "Äffin" },
1924 : : { "Henry IV", "Henry IV", "Henry IV", "Henry IV", "Henry IV" },
1925 : : { "Henry \u2163", "Henry \u2163", "Henry \u2163", "Henry IV", "Henry IV" },
1926 : : { "non-utf\x88", NULL, NULL, NULL, NULL },
1927 : : { "", "", "", "", "" },
1928 : : };
1929 : :
1930 : : #define TEST(str, mode, expected) \
1931 : : { \
1932 : : gchar *normalized = g_utf8_normalize (str, -1, mode); \
1933 : : g_assert_cmpstr (normalized, ==, expected); \
1934 : : g_free (normalized); \
1935 : : }
1936 : :
1937 [ + + ]: 7 : for (i = 0; i < G_N_ELEMENTS (tests); i++)
1938 : : {
1939 [ - + ]: 6 : TEST (tests[i].str, G_NORMALIZE_NFD, tests[i].nfd);
1940 [ - + ]: 6 : TEST (tests[i].str, G_NORMALIZE_NFC, tests[i].nfc);
1941 [ - + ]: 6 : TEST (tests[i].str, G_NORMALIZE_NFKD, tests[i].nfkd);
1942 [ - + ]: 6 : TEST (tests[i].str, G_NORMALIZE_NFKC, tests[i].nfkc);
1943 : : }
1944 : :
1945 : : #undef TEST
1946 : 1 : }
1947 : :
1948 : : int
1949 : 1 : main (int argc,
1950 : : char *argv[])
1951 : : {
1952 : 1 : g_test_init (&argc, &argv, NULL);
1953 : :
1954 : 1 : g_test_add_func ("/unicode/alnum", test_alnum);
1955 : 1 : g_test_add_func ("/unicode/alpha", test_alpha);
1956 : 1 : g_test_add_func ("/unicode/break-type", test_unichar_break_type);
1957 : 1 : g_test_add_func ("/unicode/canonical-decomposition", test_canonical_decomposition);
1958 : 1 : g_test_add_func ("/unicode/casefold", test_casefold);
1959 : 1 : g_test_add_func ("/unicode/casemap_and_casefold", test_casemap_and_casefold);
1960 : 1 : g_test_add_func ("/unicode/cases", test_cases);
1961 : 1 : g_test_add_func ("/unicode/character-type", test_unichar_character_type);
1962 : 1 : g_test_add_func ("/unicode/cntrl", test_cntrl);
1963 : 1 : g_test_add_func ("/unicode/combining-class", test_combining_class);
1964 : 1 : g_test_add_func ("/unicode/compose", test_compose);
1965 : 1 : g_test_add_func ("/unicode/decompose", test_decompose);
1966 : 1 : g_test_add_func ("/unicode/decompose-tail", test_decompose_tail);
1967 : 1 : g_test_add_func ("/unicode/defined", test_defined);
1968 : 1 : g_test_add_func ("/unicode/digit", test_digit);
1969 : 1 : g_test_add_func ("/unicode/digit-value", test_digit_value);
1970 : 1 : g_test_add_func ("/unicode/fully-decompose-canonical", test_fully_decompose_canonical);
1971 : 1 : g_test_add_func ("/unicode/fully-decompose-len", test_fully_decompose_len);
1972 : 1 : g_test_add_func ("/unicode/normalization", test_normalization);
1973 : 1 : g_test_add_func ("/unicode/graph", test_graph);
1974 : 1 : g_test_add_func ("/unicode/iso15924", test_iso15924);
1975 : 1 : g_test_add_func ("/unicode/lower", test_lower);
1976 : 1 : g_test_add_func ("/unicode/mark", test_mark);
1977 : 1 : g_test_add_func ("/unicode/mirror", test_mirror);
1978 : 1 : g_test_add_func ("/unicode/print", test_print);
1979 : 1 : g_test_add_func ("/unicode/punctuation", test_punctuation);
1980 : 1 : g_test_add_func ("/unicode/script", test_unichar_script);
1981 : 1 : g_test_add_func ("/unicode/space", test_space);
1982 : 1 : g_test_add_func ("/unicode/strdown", test_strdown);
1983 : 1 : g_test_add_func ("/unicode/strup", test_strup);
1984 : 1 : g_test_add_func ("/unicode/turkish-strupdown", test_turkish_strupdown);
1985 : 1 : g_test_add_func ("/unicode/title", test_title);
1986 : 1 : g_test_add_func ("/unicode/upper", test_upper);
1987 : 1 : g_test_add_func ("/unicode/validate", test_unichar_validate);
1988 : 1 : g_test_add_func ("/unicode/wide", test_wide);
1989 : 1 : g_test_add_func ("/unicode/xdigit", test_xdigit);
1990 : 1 : g_test_add_func ("/unicode/xdigit-value", test_xdigit_value);
1991 : 1 : g_test_add_func ("/unicode/zero-width", test_zerowidth);
1992 : 1 : g_test_add_func ("/unicode/normalize", test_normalize);
1993 : :
1994 : 1 : return g_test_run();
1995 : : }
|
