1/* 2 * Copyright © 2011 Codethink Limited 3 * Copyright © 2011 Google, Inc. 4 * 5 * This is part of HarfBuzz, a text shaping library. 6 * 7 * Permission is hereby granted, without written agreement and without 8 * license or royalty fees, to use, copy, modify, and distribute this 9 * software and its documentation for any purpose, provided that the 10 * above copyright notice and the following two paragraphs appear in 11 * all copies of this software. 12 * 13 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR 14 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES 15 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN 16 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH 17 * DAMAGE. 18 * 19 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, 20 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 21 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS 22 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO 23 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. 24 * 25 * Codethink Author(s): Ryan Lortie 26 * Google Author(s): Behdad Esfahbod 27 */ 28 29#include "hb-test.h" 30 31/* Unit tests for hb-unicode.h */ 32/* Unit tests for hb-glib.h */ 33/* Unit tests for hb-icu.h */ 34 35 36#ifdef HAVE_GLIB 37#include <hb-glib.h> 38#endif 39#ifdef HAVE_ICU 40#include <hb-icu.h> 41#endif 42 43 44/* Some useful stuff */ 45 46#define MAGIC0 0x12345678 47#define MAGIC1 0x76543210 48 49typedef struct { 50 int value; 51 gboolean freed; 52} data_t; 53 54static void free_up (void *p) 55{ 56 data_t *data = (data_t *) p; 57 58 g_assert (data->value == MAGIC0 || data->value == MAGIC1); 59 g_assert (!data->freed); 60 data->freed = TRUE; 61} 62 63static hb_script_t 64simple_get_script (hb_unicode_funcs_t *ufuncs, 65 hb_codepoint_t codepoint, 66 void *user_data) 67{ 68 data_t *data = (data_t *) user_data; 69 70 g_assert (hb_unicode_funcs_get_parent (ufuncs) != NULL); 71 g_assert_cmphex (data->value, ==, MAGIC0); 72 g_assert (!data->freed); 73 74 if ('a' <= codepoint && codepoint <= 'z') 75 return HB_SCRIPT_LATIN; 76 else 77 return HB_SCRIPT_UNKNOWN; 78} 79 80static hb_script_t 81a_is_for_arabic_get_script (hb_unicode_funcs_t *ufuncs, 82 hb_codepoint_t codepoint, 83 void *user_data) 84{ 85 data_t *data = (data_t *) user_data; 86 87 g_assert (hb_unicode_funcs_get_parent (ufuncs) != NULL); 88 g_assert_cmphex (data->value, ==, MAGIC1); 89 g_assert (!data->freed); 90 91 if (codepoint == 'a') { 92 return HB_SCRIPT_ARABIC; 93 } else { 94 hb_unicode_funcs_t *parent = hb_unicode_funcs_get_parent (ufuncs); 95 96 return hb_unicode_script (parent, codepoint); 97 } 98} 99 100 101 102/* Check all properties */ 103 104/* Some of the following tables where adapted from glib/glib/tests/utf8-misc.c. 105 * The license is compatible. */ 106 107typedef struct { 108 hb_codepoint_t unicode; 109 unsigned int value; 110} test_pair_t; 111 112static const test_pair_t combining_class_tests[] = 113{ 114 { 0x0020, 0 }, 115 { 0x0334, 1 }, 116 { 0x093C, 7 }, 117 { 0x3099, 8 }, 118 { 0x094D, 9 }, 119 { 0x05B0, 10 }, 120 { 0x05B1, 11 }, 121 { 0x05B2, 12 }, 122 { 0x05B3, 13 }, 123 { 0x05B4, 14 }, 124 { 0x05B5, 15 }, 125 { 0x05B6, 16 }, 126 { 0x05B7, 17 }, 127 { 0x05B8, 18 }, 128 { 0x05B9, 19 }, 129 { 0x05BB, 20 }, 130 { 0x05BC, 21 }, 131 { 0x05BD, 22 }, 132 { 0x05BF, 23 }, 133 { 0x05C1, 24 }, 134 { 0x05C2, 25 }, 135 { 0xFB1E, 26 }, 136 { 0x064B, 27 }, 137 { 0x064C, 28 }, 138 { 0x064D, 29 }, 139 /* ... */ 140 { 0x05AE, 228 }, 141 { 0x0300, 230 }, 142 { 0x302C, 232 }, 143 { 0x0362, 233 }, 144 { 0x0360, 234 }, 145 { 0x0345, 240 }, 146 147 { 0x111111, 0 } 148}; 149static const test_pair_t combining_class_tests_more[] = 150{ 151 /* Unicode-5.1 character additions */ 152 { 0x1DCD, 234 }, 153 154 /* Unicode-5.2 character additions */ 155 { 0xA8E0, 230 }, 156 157 /* Unicode-6.0 character additions */ 158 { 0x135D, 230 }, 159 160 { 0x111111, 0 } 161}; 162 163static const test_pair_t eastasian_width_tests[] = 164{ 165 /* Neutral */ 166 { 0x0000, 1 }, 167 { 0x0483, 1 }, 168 { 0x0641, 1 }, 169 { 0xFFFC, 1 }, 170 { 0x10000, 1 }, 171 { 0xE0001, 1 }, 172 173 /* Narrow */ 174 { 0x0020, 1 }, 175 { 0x0041, 1 }, 176 { 0x27E6, 1 }, 177 178 /* Halfwidth */ 179 { 0x20A9, 1 }, 180 { 0xFF61, 1 }, 181 { 0xFF69, 1 }, 182 { 0xFFEE, 1 }, 183 184 /* Ambiguous */ 185 { 0x00A1, 1 }, 186 { 0x00D8, 1 }, 187 { 0x02DD, 1 }, 188 { 0xE0100, 1 }, 189 { 0x100000, 1 }, 190 191 /* Fullwidth */ 192 { 0x3000, 2 }, 193 { 0xFF60, 2 }, 194 195 /* Wide */ 196 { 0x2329, 2 }, 197 { 0x3001, 2 }, 198 { 0xFE69, 2 }, 199 { 0x30000, 2 }, 200 { 0x3FFFD, 2 }, 201 202 { 0x111111, 1 } 203}; 204static const test_pair_t eastasian_width_tests_more[] = 205{ 206 /* Default Wide blocks */ 207 { 0x4DBF, 2 }, 208 { 0x9FFF, 2 }, 209 { 0xFAFF, 2 }, 210 { 0x2A6DF, 2 }, 211 { 0x2B73F, 2 }, 212 { 0x2B81F, 2 }, 213 { 0x2FA1F, 2 }, 214 215 /* Uniode-5.2 character additions */ 216 /* Wide */ 217 { 0x115F, 2 }, 218 219 /* Uniode-6.0 character additions */ 220 /* Wide */ 221 { 0x2B740, 2 }, 222 { 0x1B000, 2 }, 223 224 { 0x111111, 1 } 225}; 226 227static const test_pair_t general_category_tests[] = 228{ 229 { 0x000D, HB_UNICODE_GENERAL_CATEGORY_CONTROL }, 230 { 0x200E, HB_UNICODE_GENERAL_CATEGORY_FORMAT }, 231 { 0x0378, HB_UNICODE_GENERAL_CATEGORY_UNASSIGNED }, 232 { 0xE000, HB_UNICODE_GENERAL_CATEGORY_PRIVATE_USE }, 233 { 0xD800, HB_UNICODE_GENERAL_CATEGORY_SURROGATE }, 234 { 0x0061, HB_UNICODE_GENERAL_CATEGORY_LOWERCASE_LETTER }, 235 { 0x02B0, HB_UNICODE_GENERAL_CATEGORY_MODIFIER_LETTER }, 236 { 0x3400, HB_UNICODE_GENERAL_CATEGORY_OTHER_LETTER }, 237 { 0x01C5, HB_UNICODE_GENERAL_CATEGORY_TITLECASE_LETTER }, 238 { 0xFF21, HB_UNICODE_GENERAL_CATEGORY_UPPERCASE_LETTER }, 239 { 0x0903, HB_UNICODE_GENERAL_CATEGORY_SPACING_MARK }, 240 { 0x20DD, HB_UNICODE_GENERAL_CATEGORY_ENCLOSING_MARK }, 241 { 0xA806, HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK }, 242 { 0xFF10, HB_UNICODE_GENERAL_CATEGORY_DECIMAL_NUMBER }, 243 { 0x16EE, HB_UNICODE_GENERAL_CATEGORY_LETTER_NUMBER }, 244 { 0x17F0, HB_UNICODE_GENERAL_CATEGORY_OTHER_NUMBER }, 245 { 0x005F, HB_UNICODE_GENERAL_CATEGORY_CONNECT_PUNCTUATION }, 246 { 0x058A, HB_UNICODE_GENERAL_CATEGORY_DASH_PUNCTUATION }, 247 { 0x0F3B, HB_UNICODE_GENERAL_CATEGORY_CLOSE_PUNCTUATION }, 248 { 0x2019, HB_UNICODE_GENERAL_CATEGORY_FINAL_PUNCTUATION }, 249 { 0x2018, HB_UNICODE_GENERAL_CATEGORY_INITIAL_PUNCTUATION }, 250 { 0x2016, HB_UNICODE_GENERAL_CATEGORY_OTHER_PUNCTUATION }, 251 { 0x0F3A, HB_UNICODE_GENERAL_CATEGORY_OPEN_PUNCTUATION }, 252 { 0x20A0, HB_UNICODE_GENERAL_CATEGORY_CURRENCY_SYMBOL }, 253 { 0x309B, HB_UNICODE_GENERAL_CATEGORY_MODIFIER_SYMBOL }, 254 { 0xFB29, HB_UNICODE_GENERAL_CATEGORY_MATH_SYMBOL }, 255 { 0x00A6, HB_UNICODE_GENERAL_CATEGORY_OTHER_SYMBOL }, 256 { 0x2028, HB_UNICODE_GENERAL_CATEGORY_LINE_SEPARATOR }, 257 { 0x2029, HB_UNICODE_GENERAL_CATEGORY_PARAGRAPH_SEPARATOR }, 258 { 0x202F, HB_UNICODE_GENERAL_CATEGORY_SPACE_SEPARATOR }, 259 260 { 0x111111, HB_UNICODE_GENERAL_CATEGORY_UNASSIGNED } 261}; 262static const test_pair_t general_category_tests_more[] = 263{ 264 /* Unicode-5.2 character additions */ 265 { 0x1F131, HB_UNICODE_GENERAL_CATEGORY_OTHER_SYMBOL }, 266 267 /* Unicode-6.0 character additions */ 268 { 0x0620, HB_UNICODE_GENERAL_CATEGORY_OTHER_LETTER }, 269 270 { 0x111111, HB_UNICODE_GENERAL_CATEGORY_UNASSIGNED } 271}; 272 273static const test_pair_t mirroring_tests[] = 274{ 275 /* Some characters that do NOT mirror */ 276 { 0x0020, 0x0020 }, 277 { 0x0041, 0x0041 }, 278 { 0x00F0, 0x00F0 }, 279 { 0x27CC, 0x27CC }, 280 { 0xE01EF, 0xE01EF }, 281 { 0x1D7C3, 0x1D7C3 }, 282 { 0x100000, 0x100000 }, 283 284 /* Some characters that do mirror */ 285 { 0x0029, 0x0028 }, 286 { 0x0028, 0x0029 }, 287 { 0x003E, 0x003C }, 288 { 0x003C, 0x003E }, 289 { 0x005D, 0x005B }, 290 { 0x005B, 0x005D }, 291 { 0x007D, 0x007B }, 292 { 0x007B, 0x007D }, 293 { 0x00BB, 0x00AB }, 294 { 0x00AB, 0x00BB }, 295 { 0x226B, 0x226A }, 296 { 0x226A, 0x226B }, 297 { 0x22F1, 0x22F0 }, 298 { 0x22F0, 0x22F1 }, 299 { 0xFF60, 0xFF5F }, 300 { 0xFF5F, 0xFF60 }, 301 { 0xFF63, 0xFF62 }, 302 { 0xFF62, 0xFF63 }, 303 304 { 0x111111, 0x111111 }, 305}; 306static const test_pair_t mirroring_tests_more[] = 307{ 308 /* No new mirroring characters have been encoded in recent Unicode versions. */ 309 { 0x111111, 0x111111 } 310}; 311 312static const test_pair_t script_tests[] = 313{ 314 { 0x002A, HB_SCRIPT_COMMON }, 315 { 0x0670, HB_SCRIPT_INHERITED }, 316 { 0x060D, HB_SCRIPT_ARABIC }, 317 { 0x0559, HB_SCRIPT_ARMENIAN }, 318 { 0x09CD, HB_SCRIPT_BENGALI }, 319 { 0x31B6, HB_SCRIPT_BOPOMOFO }, 320 { 0x13A2, HB_SCRIPT_CHEROKEE }, 321 { 0x2CFD, HB_SCRIPT_COPTIC }, 322 { 0x0482, HB_SCRIPT_CYRILLIC }, 323 { 0x10401, HB_SCRIPT_DESERET }, 324 { 0x094D, HB_SCRIPT_DEVANAGARI }, 325 { 0x1258, HB_SCRIPT_ETHIOPIC }, 326 { 0x10FC, HB_SCRIPT_GEORGIAN }, 327 { 0x10341, HB_SCRIPT_GOTHIC }, 328 { 0x0375, HB_SCRIPT_GREEK }, 329 { 0x0A83, HB_SCRIPT_GUJARATI }, 330 { 0x0A3C, HB_SCRIPT_GURMUKHI }, 331 { 0x3005, HB_SCRIPT_HAN }, 332 { 0x1100, HB_SCRIPT_HANGUL }, 333 { 0x05BF, HB_SCRIPT_HEBREW }, 334 { 0x309F, HB_SCRIPT_HIRAGANA }, 335 { 0x0CBC, HB_SCRIPT_KANNADA }, 336 { 0x30FF, HB_SCRIPT_KATAKANA }, 337 { 0x17DD, HB_SCRIPT_KHMER }, 338 { 0x0EDD, HB_SCRIPT_LAO }, 339 { 0x0061, HB_SCRIPT_LATIN }, 340 { 0x0D3D, HB_SCRIPT_MALAYALAM }, 341 { 0x1843, HB_SCRIPT_MONGOLIAN }, 342 { 0x1031, HB_SCRIPT_MYANMAR }, 343 { 0x169C, HB_SCRIPT_OGHAM }, 344 { 0x10322, HB_SCRIPT_OLD_ITALIC }, 345 { 0x0B3C, HB_SCRIPT_ORIYA }, 346 { 0x16EF, HB_SCRIPT_RUNIC }, 347 { 0x0DBD, HB_SCRIPT_SINHALA }, 348 { 0x0711, HB_SCRIPT_SYRIAC }, 349 { 0x0B82, HB_SCRIPT_TAMIL }, 350 { 0x0C03, HB_SCRIPT_TELUGU }, 351 { 0x07B1, HB_SCRIPT_THAANA }, 352 { 0x0E31, HB_SCRIPT_THAI }, 353 { 0x0FD4, HB_SCRIPT_TIBETAN }, 354 { 0x1401, HB_SCRIPT_CANADIAN_SYLLABICS }, 355 { 0xA015, HB_SCRIPT_YI }, 356 { 0x1700, HB_SCRIPT_TAGALOG }, 357 { 0x1720, HB_SCRIPT_HANUNOO }, 358 { 0x1740, HB_SCRIPT_BUHID }, 359 { 0x1760, HB_SCRIPT_TAGBANWA }, 360 361 /* Unicode-4.0 additions */ 362 { 0x2800, HB_SCRIPT_BRAILLE }, 363 { 0x10808, HB_SCRIPT_CYPRIOT }, 364 { 0x1932, HB_SCRIPT_LIMBU }, 365 { 0x10480, HB_SCRIPT_OSMANYA }, 366 { 0x10450, HB_SCRIPT_SHAVIAN }, 367 { 0x10000, HB_SCRIPT_LINEAR_B }, 368 { 0x1950, HB_SCRIPT_TAI_LE }, 369 { 0x1039F, HB_SCRIPT_UGARITIC }, 370 371 /* Unicode-4.1 additions */ 372 { 0x1980, HB_SCRIPT_NEW_TAI_LUE }, 373 { 0x1A1F, HB_SCRIPT_BUGINESE }, 374 { 0x2C00, HB_SCRIPT_GLAGOLITIC }, 375 { 0x2D6F, HB_SCRIPT_TIFINAGH }, 376 { 0xA800, HB_SCRIPT_SYLOTI_NAGRI }, 377 { 0x103D0, HB_SCRIPT_OLD_PERSIAN }, 378 { 0x10A3F, HB_SCRIPT_KHAROSHTHI }, 379 380 /* Unicode-5.0 additions */ 381 { 0x0378, HB_SCRIPT_UNKNOWN }, 382 { 0x1B04, HB_SCRIPT_BALINESE }, 383 { 0x12000, HB_SCRIPT_CUNEIFORM }, 384 { 0x10900, HB_SCRIPT_PHOENICIAN }, 385 { 0xA840, HB_SCRIPT_PHAGS_PA }, 386 { 0x07C0, HB_SCRIPT_NKO }, 387 388 /* Unicode-5.1 additions */ 389 { 0xA900, HB_SCRIPT_KAYAH_LI }, 390 { 0x1C00, HB_SCRIPT_LEPCHA }, 391 { 0xA930, HB_SCRIPT_REJANG }, 392 { 0x1B80, HB_SCRIPT_SUNDANESE }, 393 { 0xA880, HB_SCRIPT_SAURASHTRA }, 394 { 0xAA00, HB_SCRIPT_CHAM }, 395 { 0x1C50, HB_SCRIPT_OL_CHIKI }, 396 { 0xA500, HB_SCRIPT_VAI }, 397 { 0x102A0, HB_SCRIPT_CARIAN }, 398 { 0x10280, HB_SCRIPT_LYCIAN }, 399 { 0x1093F, HB_SCRIPT_LYDIAN }, 400 401 { 0x111111, HB_SCRIPT_UNKNOWN } 402}; 403static const test_pair_t script_tests_more[] = 404{ 405 /* Unicode-5.2 additions */ 406 { 0x10B00, HB_SCRIPT_AVESTAN }, 407 { 0xA6A0, HB_SCRIPT_BAMUM }, 408 { 0x13000, HB_SCRIPT_EGYPTIAN_HIEROGLYPHS }, 409 { 0x10840, HB_SCRIPT_IMPERIAL_ARAMAIC }, 410 { 0x10B60, HB_SCRIPT_INSCRIPTIONAL_PAHLAVI }, 411 { 0x10B40, HB_SCRIPT_INSCRIPTIONAL_PARTHIAN }, 412 { 0xA980, HB_SCRIPT_JAVANESE }, 413 { 0x11082, HB_SCRIPT_KAITHI }, 414 { 0xA4D0, HB_SCRIPT_LISU }, 415 { 0xABE5, HB_SCRIPT_MEETEI_MAYEK }, 416 { 0x10A60, HB_SCRIPT_OLD_SOUTH_ARABIAN }, 417 { 0x10C00, HB_SCRIPT_OLD_TURKIC }, 418 { 0x0800, HB_SCRIPT_SAMARITAN }, 419 { 0x1A20, HB_SCRIPT_TAI_THAM }, 420 { 0xAA80, HB_SCRIPT_TAI_VIET }, 421 422 /* Unicode-6.0 additions */ 423 { 0x1BC0, HB_SCRIPT_BATAK }, 424 { 0x11000, HB_SCRIPT_BRAHMI }, 425 { 0x0840, HB_SCRIPT_MANDAIC }, 426 427 /* Unicode-5.2 character additions */ 428 { 0x1CED, HB_SCRIPT_INHERITED }, 429 { 0x1400, HB_SCRIPT_CANADIAN_ABORIGINAL }, 430 431 { 0x111111, HB_SCRIPT_UNKNOWN } 432}; 433 434 435typedef unsigned int (*get_func_t) (hb_unicode_funcs_t *ufuncs, 436 hb_codepoint_t unicode, 437 void *user_data); 438typedef unsigned int (*func_setter_func_t) (hb_unicode_funcs_t *ufuncs, 439 get_func_t func, 440 void *user_data, 441 hb_destroy_func_t destroy); 442typedef unsigned int (*getter_func_t) (hb_unicode_funcs_t *ufuncs, 443 hb_codepoint_t unicode); 444 445typedef struct { 446 const char *name; 447 func_setter_func_t func_setter; 448 getter_func_t getter; 449 const test_pair_t *tests; 450 unsigned int num_tests; 451 const test_pair_t *tests_more; 452 unsigned int num_tests_more; 453 unsigned int default_value; 454} property_t; 455 456#define RETURNS_UNICODE_ITSELF ((unsigned int) -1) 457 458#define PROPERTY(name, DEFAULT) \ 459 { \ 460 #name, \ 461 (func_setter_func_t) hb_unicode_funcs_set_##name##_func, \ 462 (getter_func_t) hb_unicode_##name, \ 463 name##_tests, \ 464 G_N_ELEMENTS (name##_tests), \ 465 name##_tests_more, \ 466 G_N_ELEMENTS (name##_tests_more), \ 467 DEFAULT \ 468 } 469static const property_t properties[] = 470{ 471 PROPERTY (combining_class, 0), 472 PROPERTY (eastasian_width, 1), 473 PROPERTY (general_category, (unsigned int) HB_UNICODE_GENERAL_CATEGORY_OTHER_LETTER), 474 PROPERTY (mirroring, RETURNS_UNICODE_ITSELF), 475 PROPERTY (script, (unsigned int) HB_SCRIPT_UNKNOWN) 476}; 477#undef PROPERTY 478 479static void 480test_unicode_properties (gconstpointer user_data) 481{ 482 hb_unicode_funcs_t *uf = (hb_unicode_funcs_t *) user_data; 483 unsigned int i, j; 484 gboolean failed = TRUE; 485 486 g_assert (hb_unicode_funcs_is_immutable (uf)); 487 g_assert (hb_unicode_funcs_get_parent (uf)); 488 489 for (i = 0; i < G_N_ELEMENTS (properties); i++) { 490 const property_t *p = &properties[i]; 491 const test_pair_t *tests; 492 493 g_test_message ("Testing property %s", p->name); 494 tests = p->tests; 495 for (j = 0; j < p->num_tests; j++) { 496 g_test_message ("Test %s #%d: U+%04X", p->name, j, tests[j].unicode); 497 g_assert_cmphex (p->getter (uf, tests[j].unicode), ==, tests[j].value); 498 } 499 /* These tests are from Unicode 5.2 onward and older glib/ICU 500 * don't get them right. Just warn instead of assert. */ 501 tests = p->tests_more; 502 for (j = 0; j < p->num_tests_more; j++) { 503 g_test_message ("Test %s more #%d: U+%04X", p->name, j, tests[j].unicode); 504 if (p->getter (uf, tests[j].unicode) != tests[j].value) { 505 g_test_message ("Soft fail: Received %x, expected %x", p->getter (uf, tests[j].unicode), tests[j].value); 506 failed = TRUE; 507 } 508 } 509 } 510 511 if (failed) 512 g_test_message ("Some property tests failed. You probably have an old version of one of the libraries used."); 513} 514 515static hb_codepoint_t 516default_value (hb_codepoint_t _default_value, hb_codepoint_t unicode) 517{ 518 return _default_value == RETURNS_UNICODE_ITSELF ? unicode : _default_value; 519} 520 521static void 522_test_unicode_properties_nil (hb_unicode_funcs_t *uf) 523{ 524 unsigned int i, j; 525 526 for (i = 0; i < G_N_ELEMENTS (properties); i++) { 527 const property_t *p = &properties[i]; 528 const test_pair_t *tests; 529 530 g_test_message ("Testing property %s", p->name); 531 tests = p->tests; 532 for (j = 0; j < p->num_tests; j++) { 533 g_test_message ("Test %s #%d: U+%04X", p->name, j, tests[j].unicode); 534 g_assert_cmphex (p->getter (uf, tests[j].unicode), ==, default_value (p->default_value, tests[j].unicode)); 535 } 536 tests = p->tests_more; 537 for (j = 0; j < p->num_tests_more; j++) { 538 g_test_message ("Test %s more #%d: U+%04X", p->name, j, tests[j].unicode); 539 g_assert_cmphex (p->getter (uf, tests[j].unicode), ==, default_value (p->default_value, tests[j].unicode)); 540 } 541 } 542} 543 544static void 545test_unicode_properties_nil (void) 546{ 547 hb_unicode_funcs_t *uf = hb_unicode_funcs_create (NULL); 548 549 g_assert (!hb_unicode_funcs_is_immutable (uf)); 550 _test_unicode_properties_nil (uf); 551 552 hb_unicode_funcs_destroy (uf); 553} 554 555static void 556test_unicode_properties_empty (void) 557{ 558 hb_unicode_funcs_t *uf = hb_unicode_funcs_get_empty (); 559 560 g_assert (uf); 561 g_assert (hb_unicode_funcs_is_immutable (uf)); 562 _test_unicode_properties_nil (uf); 563} 564 565 566static void 567test_unicode_chainup (void) 568{ 569 hb_unicode_funcs_t *uf, *uf2; 570 571 /* Chain-up to nil */ 572 573 uf = hb_unicode_funcs_create (NULL); 574 g_assert (!hb_unicode_funcs_is_immutable (uf)); 575 576 uf2 = hb_unicode_funcs_create (uf); 577 g_assert (hb_unicode_funcs_is_immutable (uf)); 578 hb_unicode_funcs_destroy (uf); 579 580 g_assert (!hb_unicode_funcs_is_immutable (uf2)); 581 _test_unicode_properties_nil (uf2); 582 583 hb_unicode_funcs_destroy (uf2); 584 585 /* Chain-up to default */ 586 587 uf = hb_unicode_funcs_create (hb_unicode_funcs_get_default ()); 588 g_assert (!hb_unicode_funcs_is_immutable (uf)); 589 590 uf2 = hb_unicode_funcs_create (uf); 591 g_assert (hb_unicode_funcs_is_immutable (uf)); 592 hb_unicode_funcs_destroy (uf); 593 594 g_assert (!hb_unicode_funcs_is_immutable (uf2)); 595 hb_unicode_funcs_make_immutable (uf2); 596 test_unicode_properties (uf2); 597 598 hb_unicode_funcs_destroy (uf2); 599 600} 601 602static void 603test_unicode_setters (void) 604{ 605 hb_unicode_funcs_t *uf; 606 unsigned int i; 607 608 /* This is cruel: we use script-returning functions to test all properties, 609 * but it works. */ 610 611 for (i = 0; i < G_N_ELEMENTS (properties); i++) { 612 const property_t *p = &properties[i]; 613 data_t data[2] = {{MAGIC0, FALSE}, {MAGIC1, FALSE}}; 614 615 g_test_message ("Testing property %s", p->name); 616 617 uf = hb_unicode_funcs_create (NULL); 618 g_assert (!hb_unicode_funcs_is_immutable (uf)); 619 620 p->func_setter (uf, (get_func_t) simple_get_script, &data[0], free_up); 621 622 g_assert_cmphex (p->getter (uf, 'a'), ==, HB_SCRIPT_LATIN); 623 g_assert_cmphex (p->getter (uf, '0'), ==, HB_SCRIPT_UNKNOWN); 624 625 p->func_setter (uf, (get_func_t) NULL, NULL, NULL); 626 g_assert (data[0].freed && !data[1].freed); 627 628 g_assert (!hb_unicode_funcs_is_immutable (uf)); 629 hb_unicode_funcs_make_immutable (uf); 630 g_assert (hb_unicode_funcs_is_immutable (uf)); 631 632 /* Since uf is immutable now, the following setter should do nothing. */ 633 p->func_setter (uf, (get_func_t) a_is_for_arabic_get_script, &data[1], free_up); 634 635 g_assert (data[0].freed && !data[1].freed); 636 hb_unicode_funcs_destroy (uf); 637 g_assert (data[0].freed && !data[1].freed); 638 } 639} 640 641 642 643typedef struct { 644 data_t data[2]; 645} data_fixture_t; 646 647static void 648data_fixture_init (data_fixture_t *f, gconstpointer user_data) 649{ 650 f->data[0].value = MAGIC0; 651 f->data[1].value = MAGIC1; 652} 653static void 654data_fixture_finish (data_fixture_t *f, gconstpointer user_data) 655{ 656} 657 658static void 659test_unicode_subclassing_nil (data_fixture_t *f, gconstpointer user_data) 660{ 661 hb_unicode_funcs_t *uf, *aa; 662 663 uf = hb_unicode_funcs_create (NULL); 664 665 aa = hb_unicode_funcs_create (uf); 666 667 hb_unicode_funcs_destroy (uf); 668 669 hb_unicode_funcs_set_script_func (aa, a_is_for_arabic_get_script, 670 &f->data[1], free_up); 671 672 g_assert_cmphex (hb_unicode_script (aa, 'a'), ==, HB_SCRIPT_ARABIC); 673 g_assert_cmphex (hb_unicode_script (aa, 'b'), ==, HB_SCRIPT_UNKNOWN); 674 675 g_assert (!f->data[0].freed && !f->data[1].freed); 676 hb_unicode_funcs_destroy (aa); 677 g_assert (!f->data[0].freed && f->data[1].freed); 678} 679 680static void 681test_unicode_subclassing_default (data_fixture_t *f, gconstpointer user_data) 682{ 683 hb_unicode_funcs_t *uf, *aa; 684 685 uf = hb_unicode_funcs_get_default (); 686 aa = hb_unicode_funcs_create (uf); 687 688 hb_unicode_funcs_set_script_func (aa, a_is_for_arabic_get_script, 689 &f->data[1], free_up); 690 691 g_assert_cmphex (hb_unicode_script (aa, 'a'), ==, HB_SCRIPT_ARABIC); 692 g_assert_cmphex (hb_unicode_script (aa, 'b'), ==, HB_SCRIPT_LATIN); 693 694 g_assert (!f->data[0].freed && !f->data[1].freed); 695 hb_unicode_funcs_destroy (aa); 696 g_assert (!f->data[0].freed && f->data[1].freed); 697} 698 699static void 700test_unicode_subclassing_deep (data_fixture_t *f, gconstpointer user_data) 701{ 702 hb_unicode_funcs_t *uf, *aa; 703 704 uf = hb_unicode_funcs_create (NULL); 705 706 hb_unicode_funcs_set_script_func (uf, simple_get_script, 707 &f->data[0], free_up); 708 709 aa = hb_unicode_funcs_create (uf); 710 711 hb_unicode_funcs_destroy (uf); 712 713 /* make sure the 'uf' didn't get freed, since 'aa' holds a ref */ 714 g_assert (!f->data[0].freed); 715 716 hb_unicode_funcs_set_script_func (aa, a_is_for_arabic_get_script, 717 &f->data[1], free_up); 718 719 g_assert_cmphex (hb_unicode_script (aa, 'a'), ==, HB_SCRIPT_ARABIC); 720 g_assert_cmphex (hb_unicode_script (aa, 'b'), ==, HB_SCRIPT_LATIN); 721 g_assert_cmphex (hb_unicode_script (aa, '0'), ==, HB_SCRIPT_UNKNOWN); 722 723 g_assert (!f->data[0].freed && !f->data[1].freed); 724 hb_unicode_funcs_destroy (aa); 725 g_assert (f->data[0].freed && f->data[1].freed); 726} 727 728 729static hb_script_t 730script_roundtrip_default (hb_script_t script) 731{ 732 return hb_script_from_iso15924_tag (hb_script_to_iso15924_tag (script)); 733} 734 735#ifdef HAVE_GLIB 736static hb_script_t 737script_roundtrip_glib (hb_script_t script) 738{ 739 return hb_glib_script_to_script (hb_glib_script_from_script (script)); 740} 741#endif 742 743#ifdef HAVE_ICU 744static hb_script_t 745script_roundtrip_icu (hb_script_t script) 746{ 747 return hb_icu_script_to_script (hb_icu_script_from_script (script)); 748} 749#endif 750 751static void 752test_unicode_script_roundtrip (gconstpointer user_data) 753{ 754 typedef hb_script_t (*roundtrip_func_t) (hb_script_t); 755 roundtrip_func_t roundtrip_func = (roundtrip_func_t) user_data; 756 unsigned int i; 757 gboolean failed = FALSE; 758 759 for (i = 0; i < G_N_ELEMENTS (script_tests); i++) { 760 const test_pair_t *test = &script_tests[i]; 761 hb_script_t script = test->value; 762 763 g_test_message ("Test script roundtrip #%d: %x", i, script); 764 g_assert_cmphex (script, ==, roundtrip_func (script)); 765 } 766 for (i = 0; i < G_N_ELEMENTS (script_tests_more); i++) { 767 const test_pair_t *test = &script_tests_more[i]; 768 hb_script_t script = test->value; 769 770 g_test_message ("Test script roundtrip more #%d: %x", i, script); 771 if (script != roundtrip_func (script)) { 772 g_test_message ("Soft fail: Received %x, expected %x", roundtrip_func (script), script); 773 failed = TRUE; 774 } 775 } 776 777 g_assert_cmphex (HB_SCRIPT_INVALID, ==, roundtrip_func (HB_SCRIPT_INVALID)); 778 779 if (failed) 780 g_test_message ("Some script roundtrip tests failed. You probably have an old version of one of the libraries used."); 781} 782 783 784static void 785test_unicode_normalization (gconstpointer user_data) 786{ 787 hb_unicode_funcs_t *uf = (hb_unicode_funcs_t *) user_data; 788 gunichar a, b, ab; 789 hb_codepoint_t decomposed[HB_UNICODE_MAX_DECOMPOSITION_LEN]; 790 791 792 /* Test compose() */ 793 794 /* Not composable */ 795 g_assert (!hb_unicode_compose (uf, 0x0041, 0x0042, &ab) && ab == 0); 796 g_assert (!hb_unicode_compose (uf, 0x0041, 0, &ab) && ab == 0); 797 g_assert (!hb_unicode_compose (uf, 0x0066, 0x0069, &ab) && ab == 0); 798 799 /* Singletons should not compose */ 800 g_assert (!hb_unicode_compose (uf, 0x212B, 0, &ab) && ab == 0); 801 g_assert (!hb_unicode_compose (uf, 0x00C5, 0, &ab) && ab == 0); 802 g_assert (!hb_unicode_compose (uf, 0x2126, 0, &ab) && ab == 0); 803 g_assert (!hb_unicode_compose (uf, 0x03A9, 0, &ab) && ab == 0); 804 805 /* Non-starter pairs should not compose */ 806 g_assert (!hb_unicode_compose (uf, 0x0308, 0x0301, &ab) && ab == 0); /* !0x0344 */ 807 g_assert (!hb_unicode_compose (uf, 0x0F71, 0x0F72, &ab) && ab == 0); /* !0x0F73 */ 808 809 /* Pairs */ 810 g_assert (hb_unicode_compose (uf, 0x0041, 0x030A, &ab) && ab == 0x00C5); 811 g_assert (hb_unicode_compose (uf, 0x006F, 0x0302, &ab) && ab == 0x00F4); 812 g_assert (hb_unicode_compose (uf, 0x1E63, 0x0307, &ab) && ab == 0x1E69); 813 g_assert (hb_unicode_compose (uf, 0x0073, 0x0323, &ab) && ab == 0x1E63); 814 g_assert (hb_unicode_compose (uf, 0x0064, 0x0307, &ab) && ab == 0x1E0B); 815 g_assert (hb_unicode_compose (uf, 0x0064, 0x0323, &ab) && ab == 0x1E0D); 816 817 /* Hangul */ 818 g_assert (hb_unicode_compose (uf, 0xD4CC, 0x11B6, &ab) && ab == 0xD4DB); 819 g_assert (hb_unicode_compose (uf, 0x1111, 0x1171, &ab) && ab == 0xD4CC); 820 g_assert (hb_unicode_compose (uf, 0xCE20, 0x11B8, &ab) && ab == 0xCE31); 821 g_assert (hb_unicode_compose (uf, 0x110E, 0x1173, &ab) && ab == 0xCE20); 822 823 824 /* Test decompose() */ 825 826 /* Not decomposable */ 827 g_assert (!hb_unicode_decompose (uf, 0x0041, &a, &b) && a == 0x0041 && b == 0); 828 g_assert (!hb_unicode_decompose (uf, 0xFB01, &a, &b) && a == 0xFB01 && b == 0); 829 g_assert (!hb_unicode_decompose (uf, 0x1F1EF, &a, &b) && a == 0x1F1EF && b == 0); 830 831 /* Singletons */ 832 g_assert (hb_unicode_decompose (uf, 0x212B, &a, &b) && a == 0x00C5 && b == 0); 833 g_assert (hb_unicode_decompose (uf, 0x2126, &a, &b) && a == 0x03A9 && b == 0); 834 835 /* Non-starter pairs decompose, but not compose */ 836 g_assert (hb_unicode_decompose (uf, 0x0344, &a, &b) && a == 0x0308 && b == 0x0301); 837 g_assert (hb_unicode_decompose (uf, 0x0F73, &a, &b) && a == 0x0F71 && b == 0x0F72); 838 839 /* Pairs */ 840 g_assert (hb_unicode_decompose (uf, 0x00C5, &a, &b) && a == 0x0041 && b == 0x030A); 841 g_assert (hb_unicode_decompose (uf, 0x00F4, &a, &b) && a == 0x006F && b == 0x0302); 842 g_assert (hb_unicode_decompose (uf, 0x1E69, &a, &b) && a == 0x1E63 && b == 0x0307); 843 g_assert (hb_unicode_decompose (uf, 0x1E63, &a, &b) && a == 0x0073 && b == 0x0323); 844 g_assert (hb_unicode_decompose (uf, 0x1E0B, &a, &b) && a == 0x0064 && b == 0x0307); 845 g_assert (hb_unicode_decompose (uf, 0x1E0D, &a, &b) && a == 0x0064 && b == 0x0323); 846 847 /* Hangul */ 848 g_assert (hb_unicode_decompose (uf, 0xD4DB, &a, &b) && a == 0xD4CC && b == 0x11B6); 849 g_assert (hb_unicode_decompose (uf, 0xD4CC, &a, &b) && a == 0x1111 && b == 0x1171); 850 g_assert (hb_unicode_decompose (uf, 0xCE31, &a, &b) && a == 0xCE20 && b == 0x11B8); 851 g_assert (hb_unicode_decompose (uf, 0xCE20, &a, &b) && a == 0x110E && b == 0x1173); 852 853 854 /* Test decompose_compatibility() */ 855 856 /* Not decomposable */ 857 g_assert (hb_unicode_decompose_compatibility (uf, 0x0041, decomposed) == 0); 858 g_assert (hb_unicode_decompose_compatibility (uf, 0x1F632, decomposed) == 0); 859 860 /* Singletons */ 861 g_assert (hb_unicode_decompose_compatibility (uf, 0x00B5, decomposed) == 1 && decomposed[0] == 0x03BC); 862 g_assert (hb_unicode_decompose_compatibility (uf, 0x03D6, decomposed) == 1 && decomposed[0] == 0x03C0); 863 864 /* Arabic compatibility */ 865 g_assert (hb_unicode_decompose_compatibility (uf, 0xFB54, decomposed) == 1 && decomposed[0] == 0x067B); 866 867 /* Longest decomposition ever */ 868 g_assert (18 <= HB_UNICODE_MAX_DECOMPOSITION_LEN); 869 g_assert (hb_unicode_decompose_compatibility (uf, 0xFDFA, decomposed) == 18 && decomposed[17] == 0x0645); 870 871 /* Note: we deliberately don't test characters that have canonical decompositions but no 872 * compatibility decomposition against the decompose_compatibility() function as that we 873 * leave up to implementations (for now). */ 874 875 /* Spaces */ 876 g_assert (hb_unicode_decompose_compatibility (uf, 0x2002, decomposed) == 1 && decomposed[0] == 0x0020); 877 g_assert (hb_unicode_decompose_compatibility (uf, 0x2003, decomposed) == 1 && decomposed[0] == 0x0020); 878 g_assert (hb_unicode_decompose_compatibility (uf, 0x2004, decomposed) == 1 && decomposed[0] == 0x0020); 879 g_assert (hb_unicode_decompose_compatibility (uf, 0x2005, decomposed) == 1 && decomposed[0] == 0x0020); 880 g_assert (hb_unicode_decompose_compatibility (uf, 0x2006, decomposed) == 1 && decomposed[0] == 0x0020); 881 g_assert (hb_unicode_decompose_compatibility (uf, 0x2008, decomposed) == 1 && decomposed[0] == 0x0020); 882 g_assert (hb_unicode_decompose_compatibility (uf, 0x2009, decomposed) == 1 && decomposed[0] == 0x0020); 883 g_assert (hb_unicode_decompose_compatibility (uf, 0x200A, decomposed) == 1 && decomposed[0] == 0x0020); 884 885 /* Pairs */ 886 g_assert (hb_unicode_decompose_compatibility (uf, 0x0587, decomposed) == 2 && 887 decomposed[0] == 0x0565 && decomposed[1] == 0x0582); 888 g_assert (hb_unicode_decompose_compatibility (uf, 0x2017, decomposed) == 2 && 889 decomposed[0] == 0x0020 && decomposed[1] == 0x0333); 890 g_assert (hb_unicode_decompose_compatibility (uf, 0x2025, decomposed) == 2 && 891 decomposed[0] == 0x002E && decomposed[1] == 0x002E); 892 g_assert (hb_unicode_decompose_compatibility (uf, 0x2033, decomposed) == 2 && 893 decomposed[0] == 0x2032 && decomposed[1] == 0x2032); 894 895 /* Triples */ 896 g_assert (hb_unicode_decompose_compatibility (uf, 0x2026, decomposed) == 3 && 897 decomposed[0] == 0x002E && decomposed[1] == 0x002E && decomposed[2] == 0x002E); 898 g_assert (hb_unicode_decompose_compatibility (uf, 0x2034, decomposed) == 3 && 899 decomposed[0] == 0x2032 && decomposed[1] == 0x2032 && decomposed[2] == 0x2032); 900 g_assert (hb_unicode_decompose_compatibility (uf, 0x213B, decomposed) == 3 && 901 decomposed[0] == 0x0046 && decomposed[1] == 0x0041 && decomposed[2] == 0x0058); 902} 903 904 905 906int 907main (int argc, char **argv) 908{ 909 hb_test_init (&argc, &argv); 910 911 hb_test_add (test_unicode_properties_nil); 912 hb_test_add (test_unicode_properties_empty); 913 914 hb_test_add_data_flavor (hb_unicode_funcs_get_default (), "default", test_unicode_properties); 915 hb_test_add_data_flavor (hb_unicode_funcs_get_default (), "default", test_unicode_normalization); 916 hb_test_add_data_flavor ((gconstpointer) script_roundtrip_default, "default", test_unicode_script_roundtrip); 917#ifdef HAVE_GLIB 918 hb_test_add_data_flavor (hb_glib_get_unicode_funcs (), "glib", test_unicode_properties); 919 hb_test_add_data_flavor (hb_glib_get_unicode_funcs (), "glib", test_unicode_normalization); 920 hb_test_add_data_flavor ((gconstpointer) script_roundtrip_glib, "glib", test_unicode_script_roundtrip); 921#endif 922#ifdef HAVE_ICU 923 hb_test_add_data_flavor (hb_icu_get_unicode_funcs (), "icu", test_unicode_properties); 924 hb_test_add_data_flavor (hb_icu_get_unicode_funcs (), "icu", test_unicode_normalization); 925 hb_test_add_data_flavor ((gconstpointer) script_roundtrip_icu, "icu", test_unicode_script_roundtrip); 926#endif 927 928 hb_test_add (test_unicode_chainup); 929 930 hb_test_add (test_unicode_setters); 931 932 hb_test_add_fixture (data_fixture, NULL, test_unicode_subclassing_nil); 933 hb_test_add_fixture (data_fixture, NULL, test_unicode_subclassing_default); 934 hb_test_add_fixture (data_fixture, NULL, test_unicode_subclassing_deep); 935 936 return hb_test_run (); 937} 938