test/api/test-unicode.c

   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
  49 typedef struct {
  50   int value;
  51   gboolean freed;
  52 } data_t;
  53
  54 static 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
  63 static hb_script_t
  64 simple_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
  80 static hb_script_t
  81 a_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
 107 typedef struct {
 108   hb_codepoint_t unicode;
 109   unsigned int   value;
 110 } test_pair_t;
 111
 112 static 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 };
 149 static 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   /* Unicode-6.1 character additions */
 161   {   0xA674, 230 },
 162
 163   /* Unicode-7.0 character additions */
 164   {   0x1AB0, 230 },
 165
 166   /* Unicode-8.0 character additions */
 167   {   0xA69E, 230 },
 168
 169   /* Unicode-9.0 character additions */
 170   {  0x1E000, 230 },
 171
 172   /* Unicode-10.0 character additions */
 173   {   0x1DF6, 232 },
 174
 175   /* Unicode-11.0 character additions */
 176   {   0x07FD, 220 },
 177
 178   /* Unicode-12.0 character additions */
 179   {   0x0EBA,   9 },
 180
 181   /* Unicode-13.0 character additions */
 182   {   0x1ABF, 220 },
 183
 184   { 0x111111, 0 }
 185 };
 186
 187
 188 static const test_pair_t general_category_tests[] =
 189 {
 190   {   0x000D, HB_UNICODE_GENERAL_CATEGORY_CONTROL },
 191   {   0x200E, HB_UNICODE_GENERAL_CATEGORY_FORMAT },
 192   {   0x0378, HB_UNICODE_GENERAL_CATEGORY_UNASSIGNED },
 193   {   0xE000, HB_UNICODE_GENERAL_CATEGORY_PRIVATE_USE },
 194   {   0xD800, HB_UNICODE_GENERAL_CATEGORY_SURROGATE },
 195   {   0x0061, HB_UNICODE_GENERAL_CATEGORY_LOWERCASE_LETTER },
 196   {   0x02B0, HB_UNICODE_GENERAL_CATEGORY_MODIFIER_LETTER },
 197   {   0x3400, HB_UNICODE_GENERAL_CATEGORY_OTHER_LETTER },
 198   {   0x01C5, HB_UNICODE_GENERAL_CATEGORY_TITLECASE_LETTER },
 199   {   0xFF21, HB_UNICODE_GENERAL_CATEGORY_UPPERCASE_LETTER },
 200   {   0x0903, HB_UNICODE_GENERAL_CATEGORY_SPACING_MARK },
 201   {   0x20DD, HB_UNICODE_GENERAL_CATEGORY_ENCLOSING_MARK },
 202   {   0xA806, HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK },
 203   {   0xFF10, HB_UNICODE_GENERAL_CATEGORY_DECIMAL_NUMBER },
 204   {   0x16EE, HB_UNICODE_GENERAL_CATEGORY_LETTER_NUMBER },
 205   {   0x17F0, HB_UNICODE_GENERAL_CATEGORY_OTHER_NUMBER },
 206   {   0x005F, HB_UNICODE_GENERAL_CATEGORY_CONNECT_PUNCTUATION },
 207   {   0x058A, HB_UNICODE_GENERAL_CATEGORY_DASH_PUNCTUATION },
 208   {   0x0F3B, HB_UNICODE_GENERAL_CATEGORY_CLOSE_PUNCTUATION },
 209   {   0x2019, HB_UNICODE_GENERAL_CATEGORY_FINAL_PUNCTUATION },
 210   {   0x2018, HB_UNICODE_GENERAL_CATEGORY_INITIAL_PUNCTUATION },
 211   {   0x2016, HB_UNICODE_GENERAL_CATEGORY_OTHER_PUNCTUATION },
 212   {   0x0F3A, HB_UNICODE_GENERAL_CATEGORY_OPEN_PUNCTUATION },
 213   {   0x20A0, HB_UNICODE_GENERAL_CATEGORY_CURRENCY_SYMBOL },
 214   {   0x309B, HB_UNICODE_GENERAL_CATEGORY_MODIFIER_SYMBOL },
 215   {   0xFB29, HB_UNICODE_GENERAL_CATEGORY_MATH_SYMBOL },
 216   {   0x00A6, HB_UNICODE_GENERAL_CATEGORY_OTHER_SYMBOL },
 217   {   0x2028, HB_UNICODE_GENERAL_CATEGORY_LINE_SEPARATOR },
 218   {   0x2029, HB_UNICODE_GENERAL_CATEGORY_PARAGRAPH_SEPARATOR },
 219   {   0x202F, HB_UNICODE_GENERAL_CATEGORY_SPACE_SEPARATOR },
 220
 221   { 0x111111, HB_UNICODE_GENERAL_CATEGORY_UNASSIGNED }
 222 };
 223 static const test_pair_t general_category_tests_more[] =
 224 {
 225   /* Unicode-5.2 character additions */
 226   {  0x1F131, HB_UNICODE_GENERAL_CATEGORY_OTHER_SYMBOL },
 227
 228   /* Unicode-6.0 character additions */
 229   {   0x0620, HB_UNICODE_GENERAL_CATEGORY_OTHER_LETTER },
 230
 231   /* Unicode-6.1 character additions */
 232   {   0x058F, HB_UNICODE_GENERAL_CATEGORY_CURRENCY_SYMBOL },
 233
 234   /* Unicode-6.2 character additions */
 235   {   0x20BA, HB_UNICODE_GENERAL_CATEGORY_CURRENCY_SYMBOL },
 236
 237   /* Unicode-6.3 character additions */
 238   {   0x061C, HB_UNICODE_GENERAL_CATEGORY_FORMAT },
 239
 240   /* Unicode-7.0 character additions */
 241   {   0x058D, HB_UNICODE_GENERAL_CATEGORY_OTHER_SYMBOL },
 242
 243   /* Unicode-8.0 character additions */
 244   {   0x08E3, HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK },
 245
 246   /* Unicode-9.0 character additions */
 247   {   0x08D4, HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK },
 248
 249   /* Unicode-10.0 character additions */
 250   {   0x09FD, HB_UNICODE_GENERAL_CATEGORY_OTHER_PUNCTUATION },
 251
 252   /* Unicode-11.0 character additions */
 253   {   0x0560, HB_UNICODE_GENERAL_CATEGORY_LOWERCASE_LETTER },
 254
 255   /* Unicode-12.0 character additions */
 256   {   0x0C77, HB_UNICODE_GENERAL_CATEGORY_OTHER_PUNCTUATION },
 257
 258   /* Unicode-12.1 character additions */
 259   {   0x32FF, HB_UNICODE_GENERAL_CATEGORY_OTHER_SYMBOL },
 260
 261   /* Unicode-13.0 character additions */
 262   {   0x08BE, HB_UNICODE_GENERAL_CATEGORY_OTHER_LETTER },
 263
 264   { 0x111111, HB_UNICODE_GENERAL_CATEGORY_UNASSIGNED }
 265 };
 266
 267 static const test_pair_t mirroring_tests[] =
 268 {
 269   /* Some characters that do NOT mirror */
 270   {   0x0020, 0x0020 },
 271   {   0x0041, 0x0041 },
 272   {   0x00F0, 0x00F0 },
 273   {   0x27CC, 0x27CC },
 274   {  0xE01EF, 0xE01EF },
 275   {  0x1D7C3, 0x1D7C3 },
 276   { 0x100000, 0x100000 },
 277
 278   /* Some characters that do mirror */
 279   {   0x0029, 0x0028 },
 280   {   0x0028, 0x0029 },
 281   {   0x003E, 0x003C },
 282   {   0x003C, 0x003E },
 283   {   0x005D, 0x005B },
 284   {   0x005B, 0x005D },
 285   {   0x007D, 0x007B },
 286   {   0x007B, 0x007D },
 287   {   0x00BB, 0x00AB },
 288   {   0x00AB, 0x00BB },
 289   {   0x226B, 0x226A },
 290   {   0x226A, 0x226B },
 291   {   0x22F1, 0x22F0 },
 292   {   0x22F0, 0x22F1 },
 293   {   0xFF60, 0xFF5F },
 294   {   0xFF5F, 0xFF60 },
 295   {   0xFF63, 0xFF62 },
 296   {   0xFF62, 0xFF63 },
 297
 298   { 0x111111, 0x111111 },
 299 };
 300 static const test_pair_t mirroring_tests_more[] =
 301 {
 302   /* Unicode-6.1 character additions */
 303   {   0x27CB, 0x27CD },
 304
 305   /* Unicode-11.0 character additions */
 306   {   0x2BFE, 0x221F },
 307
 308   { 0x111111, 0x111111 }
 309 };
 310
 311 static const test_pair_t script_tests[] =
 312 {
 313   {   0x002A, HB_SCRIPT_COMMON },
 314   {   0x0670, HB_SCRIPT_INHERITED },
 315   {   0x060D, HB_SCRIPT_ARABIC },
 316   {   0x0559, HB_SCRIPT_ARMENIAN },
 317   {   0x09CD, HB_SCRIPT_BENGALI },
 318   {   0x31B6, HB_SCRIPT_BOPOMOFO },
 319   {   0x13A2, HB_SCRIPT_CHEROKEE },
 320   {   0x2CFD, HB_SCRIPT_COPTIC },
 321   {   0x0482, HB_SCRIPT_CYRILLIC },
 322   {  0x10401, HB_SCRIPT_DESERET },
 323   {   0x094D, HB_SCRIPT_DEVANAGARI },
 324   {   0x1258, HB_SCRIPT_ETHIOPIC },
 325   {   0x10FC, HB_SCRIPT_GEORGIAN },
 326   {  0x10341, HB_SCRIPT_GOTHIC },
 327   {   0x0375, HB_SCRIPT_GREEK },
 328   {   0x0A83, HB_SCRIPT_GUJARATI },
 329   {   0x0A3C, HB_SCRIPT_GURMUKHI },
 330   {   0x3005, HB_SCRIPT_HAN },
 331   {   0x1100, HB_SCRIPT_HANGUL },
 332   {   0x05BF, HB_SCRIPT_HEBREW },
 333   {   0x309F, HB_SCRIPT_HIRAGANA },
 334   {   0x0CBC, HB_SCRIPT_KANNADA },
 335   {   0x30FF, HB_SCRIPT_KATAKANA },
 336   {   0x17DD, HB_SCRIPT_KHMER },
 337   {   0x0EDD, HB_SCRIPT_LAO },
 338   {   0x0061, HB_SCRIPT_LATIN },
 339   {   0x0D3D, HB_SCRIPT_MALAYALAM },
 340   {   0x1843, HB_SCRIPT_MONGOLIAN },
 341   {   0x1031, HB_SCRIPT_MYANMAR },
 342   {   0x169C, HB_SCRIPT_OGHAM },
 343   {  0x10322, HB_SCRIPT_OLD_ITALIC },
 344   {   0x0B3C, HB_SCRIPT_ORIYA },
 345   {   0x16EF, HB_SCRIPT_RUNIC },
 346   {   0x0DBD, HB_SCRIPT_SINHALA },
 347   {   0x0711, HB_SCRIPT_SYRIAC },
 348   {   0x0B82, HB_SCRIPT_TAMIL },
 349   {   0x0C03, HB_SCRIPT_TELUGU },
 350   {   0x07B1, HB_SCRIPT_THAANA },
 351   {   0x0E31, HB_SCRIPT_THAI },
 352   {   0x0FD4, HB_SCRIPT_TIBETAN },
 353   {   0x1401, HB_SCRIPT_CANADIAN_SYLLABICS },
 354   {   0xA015, HB_SCRIPT_YI },
 355   {   0x1700, HB_SCRIPT_TAGALOG },
 356   {   0x1720, HB_SCRIPT_HANUNOO },
 357   {   0x1740, HB_SCRIPT_BUHID },
 358   {   0x1760, HB_SCRIPT_TAGBANWA },
 359
 360   /* Unicode-4.0 additions */
 361   {   0x2800, HB_SCRIPT_BRAILLE },
 362   {  0x10808, HB_SCRIPT_CYPRIOT },
 363   {   0x1932, HB_SCRIPT_LIMBU },
 364   {  0x10480, HB_SCRIPT_OSMANYA },
 365   {  0x10450, HB_SCRIPT_SHAVIAN },
 366   {  0x10000, HB_SCRIPT_LINEAR_B },
 367   {   0x1950, HB_SCRIPT_TAI_LE },
 368   {  0x1039F, HB_SCRIPT_UGARITIC },
 369
 370   /* Unicode-4.1 additions */
 371   {   0x1980, HB_SCRIPT_NEW_TAI_LUE },
 372   {   0x1A1F, HB_SCRIPT_BUGINESE },
 373   {   0x2C00, HB_SCRIPT_GLAGOLITIC },
 374   {   0x2D6F, HB_SCRIPT_TIFINAGH },
 375   {   0xA800, HB_SCRIPT_SYLOTI_NAGRI },
 376   {  0x103D0, HB_SCRIPT_OLD_PERSIAN },
 377   {  0x10A3F, HB_SCRIPT_KHAROSHTHI },
 378
 379   /* Unicode-5.0 additions */
 380   {   0x0378, HB_SCRIPT_UNKNOWN },
 381   {   0x1B04, HB_SCRIPT_BALINESE },
 382   {  0x12000, HB_SCRIPT_CUNEIFORM },
 383   {  0x10900, HB_SCRIPT_PHOENICIAN },
 384   {   0xA840, HB_SCRIPT_PHAGS_PA },
 385   {   0x07C0, HB_SCRIPT_NKO },
 386
 387   /* Unicode-5.1 additions */
 388   {   0xA900, HB_SCRIPT_KAYAH_LI },
 389   {   0x1C00, HB_SCRIPT_LEPCHA },
 390   {   0xA930, HB_SCRIPT_REJANG },
 391   {   0x1B80, HB_SCRIPT_SUNDANESE },
 392   {   0xA880, HB_SCRIPT_SAURASHTRA },
 393   {   0xAA00, HB_SCRIPT_CHAM },
 394   {   0x1C50, HB_SCRIPT_OL_CHIKI },
 395   {   0xA500, HB_SCRIPT_VAI },
 396   {  0x102A0, HB_SCRIPT_CARIAN },
 397   {  0x10280, HB_SCRIPT_LYCIAN },
 398   {  0x1093F, HB_SCRIPT_LYDIAN },
 399
 400   { 0x111111, HB_SCRIPT_UNKNOWN }
 401 };
 402 static const test_pair_t script_tests_more[] =
 403 {
 404   /* Unicode-5.2 additions */
 405   {  0x10B00, HB_SCRIPT_AVESTAN },
 406   {   0xA6A0, HB_SCRIPT_BAMUM },
 407   {   0x1400, HB_SCRIPT_CANADIAN_ABORIGINAL },
 408   {  0x13000, HB_SCRIPT_EGYPTIAN_HIEROGLYPHS },
 409   {  0x10840, HB_SCRIPT_IMPERIAL_ARAMAIC },
 410   {   0x1CED, HB_SCRIPT_INHERITED },
 411   {  0x10B60, HB_SCRIPT_INSCRIPTIONAL_PAHLAVI },
 412   {  0x10B40, HB_SCRIPT_INSCRIPTIONAL_PARTHIAN },
 413   {   0xA980, HB_SCRIPT_JAVANESE },
 414   {  0x11082, HB_SCRIPT_KAITHI },
 415   {   0xA4D0, HB_SCRIPT_LISU },
 416   {   0xABE5, HB_SCRIPT_MEETEI_MAYEK },
 417   {  0x10A60, HB_SCRIPT_OLD_SOUTH_ARABIAN },
 418   {  0x10C00, HB_SCRIPT_OLD_TURKIC },
 419   {   0x0800, HB_SCRIPT_SAMARITAN },
 420   {   0x1A20, HB_SCRIPT_TAI_THAM },
 421   {   0xAA80, HB_SCRIPT_TAI_VIET },
 422
 423   /* Unicode-6.0 additions */
 424   {   0x1BC0, HB_SCRIPT_BATAK },
 425   {  0x11000, HB_SCRIPT_BRAHMI },
 426   {   0x0840, HB_SCRIPT_MANDAIC },
 427
 428   /* Unicode-6.1 additions */
 429   {  0x10980, HB_SCRIPT_MEROITIC_HIEROGLYPHS },
 430   {  0x109A0, HB_SCRIPT_MEROITIC_CURSIVE },
 431   {  0x110D0, HB_SCRIPT_SORA_SOMPENG },
 432   {  0x11100, HB_SCRIPT_CHAKMA },
 433   {  0x11180, HB_SCRIPT_SHARADA },
 434   {  0x11680, HB_SCRIPT_TAKRI },
 435   {  0x16F00, HB_SCRIPT_MIAO },
 436
 437   /* Unicode-6.2 additions */
 438   {   0x20BA, HB_SCRIPT_COMMON },
 439
 440   /* Unicode-6.3 additions */
 441   {   0x2066, HB_SCRIPT_COMMON },
 442
 443   /* Unicode-7.0 additions */
 444   {   0x10350, HB_SCRIPT_OLD_PERMIC },
 445   {   0x10500, HB_SCRIPT_ELBASAN },
 446   {   0x10530, HB_SCRIPT_CAUCASIAN_ALBANIAN },
 447   {   0x10600, HB_SCRIPT_LINEAR_A },
 448   {   0x10860, HB_SCRIPT_PALMYRENE },
 449   {   0x10880, HB_SCRIPT_NABATAEAN },
 450   {   0x10A80, HB_SCRIPT_OLD_NORTH_ARABIAN },
 451   {   0x10AC0, HB_SCRIPT_MANICHAEAN },
 452   {   0x10B80, HB_SCRIPT_PSALTER_PAHLAVI },
 453   {   0x11150, HB_SCRIPT_MAHAJANI },
 454   {   0x11200, HB_SCRIPT_KHOJKI },
 455   {   0x112B0, HB_SCRIPT_KHUDAWADI },
 456   {   0x11300, HB_SCRIPT_GRANTHA },
 457   {   0x11480, HB_SCRIPT_TIRHUTA },
 458   {   0x11580, HB_SCRIPT_SIDDHAM },
 459   {   0x11600, HB_SCRIPT_MODI },
 460   {   0x118A0, HB_SCRIPT_WARANG_CITI },
 461   {   0x11AC0, HB_SCRIPT_PAU_CIN_HAU },
 462   {   0x16A40, HB_SCRIPT_MRO },
 463   {   0x16AD0, HB_SCRIPT_BASSA_VAH },
 464   {   0x16B00, HB_SCRIPT_PAHAWH_HMONG },
 465   {   0x1BC00, HB_SCRIPT_DUPLOYAN },
 466   {   0x1E800, HB_SCRIPT_MENDE_KIKAKUI },
 467
 468   /* Unicode-8.0 additions */
 469   {   0x108E0, HB_SCRIPT_HATRAN },
 470   {   0x10C80, HB_SCRIPT_OLD_HUNGARIAN },
 471   {   0x11280, HB_SCRIPT_MULTANI },
 472   {   0x11700, HB_SCRIPT_AHOM },
 473   {   0x14400, HB_SCRIPT_ANATOLIAN_HIEROGLYPHS },
 474   {   0x1D800, HB_SCRIPT_SIGNWRITING },
 475
 476   /* Unicode-9.0 additions */
 477   {   0x104B0, HB_SCRIPT_OSAGE },
 478   {   0x11400, HB_SCRIPT_NEWA },
 479   {   0x11C00, HB_SCRIPT_BHAIKSUKI },
 480   {   0x11C70, HB_SCRIPT_MARCHEN },
 481   {   0x17000, HB_SCRIPT_TANGUT },
 482   {   0x1E900, HB_SCRIPT_ADLAM },
 483
 484   /* Unicode-10.0 additions */
 485   {   0x11A00, HB_SCRIPT_ZANABAZAR_SQUARE },
 486   {   0x11A50, HB_SCRIPT_SOYOMBO },
 487   {   0x11D00, HB_SCRIPT_MASARAM_GONDI },
 488   {   0x1B170, HB_SCRIPT_NUSHU },
 489
 490   /* Unicode-11.0 additions */
 491   {   0x10D00, HB_SCRIPT_HANIFI_ROHINGYA },
 492   {   0x10F00, HB_SCRIPT_OLD_SOGDIAN },
 493   {   0x10F30, HB_SCRIPT_SOGDIAN },
 494   {   0x11800, HB_SCRIPT_DOGRA },
 495   {   0x11D60, HB_SCRIPT_GUNJALA_GONDI },
 496   {   0x11EE0, HB_SCRIPT_MAKASAR },
 497   {   0x16E40, HB_SCRIPT_MEDEFAIDRIN },
 498
 499   /* Unicode-12.0 additions */
 500   {   0x10FE0, HB_SCRIPT_ELYMAIC },
 501   {   0x119A0, HB_SCRIPT_NANDINAGARI },
 502   {   0x1E100, HB_SCRIPT_NYIAKENG_PUACHUE_HMONG },
 503   {   0x1E2C0, HB_SCRIPT_WANCHO },
 504
 505   /* Unicode-12.1 additions */
 506   {   0x32FF, HB_SCRIPT_COMMON },
 507
 508   /* Unicode-13.0 additions */
 509   {   0x10E80, HB_SCRIPT_YEZIDI },
 510   {   0x10FB0, HB_SCRIPT_CHORASMIAN },
 511   {   0x11900, HB_SCRIPT_DIVES_AKURU },
 512   {   0x18B00, HB_SCRIPT_KHITAN_SMALL_SCRIPT },
 513
 514   { 0x111111, HB_SCRIPT_UNKNOWN }
 515 };
 516
 517
 518 typedef unsigned int (*get_func_t)         (hb_unicode_funcs_t *ufuncs,
 519                                             hb_codepoint_t      unicode,
 520                                             void               *user_data);
 521 typedef unsigned int (*func_setter_func_t) (hb_unicode_funcs_t *ufuncs,
 522                                             get_func_t          func,
 523                                             void               *user_data,
 524                                             hb_destroy_func_t   destroy);
 525 typedef unsigned int (*getter_func_t)      (hb_unicode_funcs_t *ufuncs,
 526                                             hb_codepoint_t      unicode);
 527
 528 typedef struct {
 529   const char         *name;
 530   func_setter_func_t  func_setter;
 531   getter_func_t       getter;
 532   const test_pair_t  *tests;
 533   unsigned int        num_tests;
 534   const test_pair_t  *tests_more;
 535   unsigned int        num_tests_more;
 536   unsigned int        default_value;
 537 } property_t;
 538
 539 #define RETURNS_UNICODE_ITSELF ((unsigned int) -1)
 540
 541 #define PROPERTY(name, DEFAULT) \
 542   { \
 543     #name, \
 544     (func_setter_func_t) hb_unicode_funcs_set_##name##_func, \
 545     (getter_func_t) hb_unicode_##name, \
 546     name##_tests, \
 547     G_N_ELEMENTS (name##_tests), \
 548     name##_tests_more, \
 549     G_N_ELEMENTS (name##_tests_more), \
 550     DEFAULT \
 551   }
 552 static const property_t properties[] =
 553 {
 554   PROPERTY (combining_class, 0),
 555   PROPERTY (general_category, (unsigned int) HB_UNICODE_GENERAL_CATEGORY_OTHER_LETTER),
 556   PROPERTY (mirroring, RETURNS_UNICODE_ITSELF),
 557   PROPERTY (script, (unsigned int) HB_SCRIPT_UNKNOWN)
 558 };
 559 #undef PROPERTY
 560
 561 static void
 562 test_unicode_properties (gconstpointer user_data, hb_bool_t lenient)
 563 {
 564   hb_unicode_funcs_t *uf = (hb_unicode_funcs_t *) user_data;
 565   unsigned int i, j;
 566   gboolean failed = TRUE;
 567
 568   g_assert (hb_unicode_funcs_is_immutable (uf));
 569   g_assert (hb_unicode_funcs_get_parent (uf));
 570
 571   for (i = 0; i < G_N_ELEMENTS (properties); i++) {
 572     const property_t *p = &properties[i];
 573     const test_pair_t *tests;
 574
 575     g_test_message ("Testing property %s", p->name);
 576     tests = p->tests;
 577     for (j = 0; j < p->num_tests; j++) {
 578       g_test_message ("Test %s #%d: U+%04X", p->name, j, tests[j].unicode);
 579       g_assert_cmphex (p->getter (uf, tests[j].unicode), ==, tests[j].value);
 580     }
 581     /* These tests are from Unicode 5.2 onward and older glib/ICU
 582      * don't get them right.  Just warn instead of assert. */
 583     tests = p->tests_more;
 584     for (j = 0; j < p->num_tests_more; j++) {
 585       g_test_message ("Test %s more #%d: U+%04X", p->name, j, tests[j].unicode);
 586       if (lenient) {
 587         if (p->getter (uf, tests[j].unicode) != tests[j].value) {
 588           g_test_message ("Soft fail: Received %x, expected %x", p->getter (uf, tests[j].unicode), tests[j].value);
 589           failed = TRUE;
 590         }
 591       }
 592       else
 593         g_assert_cmphex (p->getter (uf, tests[j].unicode), ==, tests[j].value);
 594     }
 595   }
 596
 597   if (failed)
 598     g_test_message ("Some property tests failed.  You probably have an old version of one of the libraries used.");
 599 }
 600 static void
 601 test_unicode_properties_lenient (gconstpointer user_data)
 602 {
 603   test_unicode_properties (user_data, TRUE);
 604 }
 605 static void
 606 test_unicode_properties_strict (gconstpointer user_data)
 607 {
 608   test_unicode_properties (user_data, FALSE);
 609 }
 610
 611 static hb_codepoint_t
 612 default_value (hb_codepoint_t _default_value, hb_codepoint_t unicode)
 613 {
 614   return _default_value == RETURNS_UNICODE_ITSELF ?  unicode : _default_value;
 615 }
 616
 617 static void
 618 _test_unicode_properties_nil (hb_unicode_funcs_t *uf)
 619 {
 620   unsigned int i, j;
 621
 622   for (i = 0; i < G_N_ELEMENTS (properties); i++) {
 623     const property_t *p = &properties[i];
 624     const test_pair_t *tests;
 625
 626     g_test_message ("Testing property %s", p->name);
 627     tests = p->tests;
 628     for (j = 0; j < p->num_tests; j++) {
 629       g_test_message ("Test %s #%d: U+%04X", p->name, j, tests[j].unicode);
 630       g_assert_cmphex (p->getter (uf, tests[j].unicode), ==, default_value (p->default_value, tests[j].unicode));
 631     }
 632     tests = p->tests_more;
 633     for (j = 0; j < p->num_tests_more; j++) {
 634       g_test_message ("Test %s more #%d: U+%04X", p->name, j, tests[j].unicode);
 635       g_assert_cmphex (p->getter (uf, tests[j].unicode), ==, default_value (p->default_value, tests[j].unicode));
 636     }
 637   }
 638 }
 639
 640 static void
 641 test_unicode_properties_nil (void)
 642 {
 643   hb_unicode_funcs_t *uf = hb_unicode_funcs_create (NULL);
 644
 645   g_assert (!hb_unicode_funcs_is_immutable (uf));
 646   _test_unicode_properties_nil (uf);
 647
 648   hb_unicode_funcs_destroy (uf);
 649 }
 650
 651 static void
 652 test_unicode_properties_empty (void)
 653 {
 654   hb_unicode_funcs_t *uf = hb_unicode_funcs_get_empty ();
 655
 656   g_assert (uf);
 657   g_assert (hb_unicode_funcs_is_immutable (uf));
 658   _test_unicode_properties_nil (uf);
 659 }
 660
 661
 662 static void
 663 test_unicode_chainup (void)
 664 {
 665   hb_unicode_funcs_t *uf, *uf2;
 666
 667   /* Chain-up to nil */
 668
 669   uf = hb_unicode_funcs_create (NULL);
 670   g_assert (!hb_unicode_funcs_is_immutable (uf));
 671
 672   uf2 = hb_unicode_funcs_create (uf);
 673   g_assert (hb_unicode_funcs_is_immutable (uf));
 674   hb_unicode_funcs_destroy (uf);
 675
 676   g_assert (!hb_unicode_funcs_is_immutable (uf2));
 677   _test_unicode_properties_nil (uf2);
 678
 679   hb_unicode_funcs_destroy (uf2);
 680
 681   /* Chain-up to default */
 682
 683   uf = hb_unicode_funcs_create (hb_unicode_funcs_get_default ());
 684   g_assert (!hb_unicode_funcs_is_immutable (uf));
 685
 686   uf2 = hb_unicode_funcs_create (uf);
 687   g_assert (hb_unicode_funcs_is_immutable (uf));
 688   hb_unicode_funcs_destroy (uf);
 689
 690   g_assert (!hb_unicode_funcs_is_immutable (uf2));
 691   hb_unicode_funcs_make_immutable (uf2);
 692   test_unicode_properties_strict (uf2);
 693
 694   hb_unicode_funcs_destroy (uf2);
 695
 696 }
 697
 698 static void
 699 test_unicode_setters (void)
 700 {
 701   hb_unicode_funcs_t *uf;
 702   unsigned int i;
 703
 704   /* This is cruel: we use script-returning functions to test all properties,
 705    * but it works. */
 706
 707   for (i = 0; i < G_N_ELEMENTS (properties); i++) {
 708     const property_t *p = &properties[i];
 709     data_t data[2] = {{MAGIC0, FALSE}, {MAGIC1, FALSE}};
 710
 711     g_test_message ("Testing property %s", p->name);
 712
 713     uf = hb_unicode_funcs_create (NULL);
 714     g_assert (!hb_unicode_funcs_is_immutable (uf));
 715
 716     p->func_setter (uf, (get_func_t) simple_get_script, &data[0], free_up);
 717
 718     g_assert_cmphex (p->getter (uf, 'a'), ==, HB_SCRIPT_LATIN);
 719     g_assert_cmphex (p->getter (uf, '0'), ==, HB_SCRIPT_UNKNOWN);
 720
 721     p->func_setter (uf, (get_func_t) NULL, NULL, NULL);
 722     g_assert (data[0].freed && !data[1].freed);
 723
 724     g_assert (!hb_unicode_funcs_is_immutable (uf));
 725     hb_unicode_funcs_make_immutable (uf);
 726     g_assert (hb_unicode_funcs_is_immutable (uf));
 727
 728     /* Since uf is immutable now, the following setter should do nothing. */
 729     p->func_setter (uf, (get_func_t) a_is_for_arabic_get_script, &data[1], free_up);
 730
 731     g_assert (data[0].freed && !data[1].freed);
 732     hb_unicode_funcs_destroy (uf);
 733     g_assert (data[0].freed && !data[1].freed);
 734   }
 735 }
 736
 737
 738
 739 typedef struct {
 740   data_t data[2];
 741 } data_fixture_t;
 742
 743 static void
 744 data_fixture_init (data_fixture_t *f, gconstpointer user_data HB_UNUSED)
 745 {
 746   f->data[0].value = MAGIC0;
 747   f->data[1].value = MAGIC1;
 748 }
 749 static void
 750 data_fixture_finish (data_fixture_t *f HB_UNUSED, gconstpointer user_data HB_UNUSED)
 751 {
 752 }
 753
 754 static void
 755 test_unicode_subclassing_nil (data_fixture_t *f, gconstpointer user_data HB_UNUSED)
 756 {
 757   hb_unicode_funcs_t *uf, *aa;
 758
 759   uf = hb_unicode_funcs_create (NULL);
 760
 761   aa = hb_unicode_funcs_create (uf);
 762
 763   hb_unicode_funcs_destroy (uf);
 764
 765   hb_unicode_funcs_set_script_func (aa, a_is_for_arabic_get_script,
 766                                     &f->data[1], free_up);
 767
 768   g_assert_cmphex (hb_unicode_script (aa, 'a'), ==, HB_SCRIPT_ARABIC);
 769   g_assert_cmphex (hb_unicode_script (aa, 'b'), ==, HB_SCRIPT_UNKNOWN);
 770
 771   g_assert (!f->data[0].freed && !f->data[1].freed);
 772   hb_unicode_funcs_destroy (aa);
 773   g_assert (!f->data[0].freed && f->data[1].freed);
 774 }
 775
 776 static void
 777 test_unicode_subclassing_default (data_fixture_t *f, gconstpointer user_data HB_UNUSED)
 778 {
 779   hb_unicode_funcs_t *uf, *aa;
 780
 781   uf = hb_unicode_funcs_get_default ();
 782   aa = hb_unicode_funcs_create (uf);
 783
 784   hb_unicode_funcs_set_script_func (aa, a_is_for_arabic_get_script,
 785                                     &f->data[1], free_up);
 786
 787   g_assert_cmphex (hb_unicode_script (aa, 'a'), ==, HB_SCRIPT_ARABIC);
 788   g_assert_cmphex (hb_unicode_script (aa, 'b'), ==, HB_SCRIPT_LATIN);
 789
 790   g_assert (!f->data[0].freed && !f->data[1].freed);
 791   hb_unicode_funcs_destroy (aa);
 792   g_assert (!f->data[0].freed && f->data[1].freed);
 793 }
 794
 795 static void
 796 test_unicode_subclassing_deep (data_fixture_t *f, gconstpointer user_data HB_UNUSED)
 797 {
 798   hb_unicode_funcs_t *uf, *aa;
 799
 800   uf = hb_unicode_funcs_create (NULL);
 801
 802   hb_unicode_funcs_set_script_func (uf, simple_get_script,
 803                                     &f->data[0], free_up);
 804
 805   aa = hb_unicode_funcs_create (uf);
 806
 807   hb_unicode_funcs_destroy (uf);
 808
 809   /* make sure the 'uf' didn't get freed, since 'aa' holds a ref */
 810   g_assert (!f->data[0].freed);
 811
 812   hb_unicode_funcs_set_script_func (aa, a_is_for_arabic_get_script,
 813                                     &f->data[1], free_up);
 814
 815   g_assert_cmphex (hb_unicode_script (aa, 'a'), ==, HB_SCRIPT_ARABIC);
 816   g_assert_cmphex (hb_unicode_script (aa, 'b'), ==, HB_SCRIPT_LATIN);
 817   g_assert_cmphex (hb_unicode_script (aa, '0'), ==, HB_SCRIPT_UNKNOWN);
 818
 819   g_assert (!f->data[0].freed && !f->data[1].freed);
 820   hb_unicode_funcs_destroy (aa);
 821   g_assert (f->data[0].freed && f->data[1].freed);
 822 }
 823
 824
 825 static hb_script_t
 826 script_roundtrip_default (hb_script_t script)
 827 {
 828   return hb_script_from_iso15924_tag (hb_script_to_iso15924_tag (script));
 829 }
 830
 831 #ifdef HAVE_GLIB
 832 static hb_script_t
 833 script_roundtrip_glib (hb_script_t script)
 834 {
 835   return hb_glib_script_to_script (hb_glib_script_from_script (script));
 836 }
 837 #endif
 838
 839 #ifdef HAVE_ICU
 840 static hb_script_t
 841 script_roundtrip_icu (hb_script_t script)
 842 {
 843   return hb_icu_script_to_script (hb_icu_script_from_script (script));
 844 }
 845 #endif
 846
 847 static void
 848 test_unicode_script_roundtrip (gconstpointer user_data)
 849 {
 850   typedef hb_script_t (*roundtrip_func_t) (hb_script_t);
 851   roundtrip_func_t roundtrip_func = (roundtrip_func_t) user_data;
 852   unsigned int i;
 853   gboolean failed = FALSE;
 854
 855   for (i = 0; i < G_N_ELEMENTS (script_tests); i++) {
 856     const test_pair_t *test = &script_tests[i];
 857     hb_script_t script = test->value;
 858
 859     g_test_message ("Test script roundtrip #%d: %x", i, script);
 860     g_assert_cmphex (script, ==, roundtrip_func (script));
 861   }
 862   for (i = 0; i < G_N_ELEMENTS (script_tests_more); i++) {
 863     const test_pair_t *test = &script_tests_more[i];
 864     hb_script_t script = test->value;
 865
 866     g_test_message ("Test script roundtrip more #%d: %x", i, script);
 867     if (script != roundtrip_func (script)) {
 868       g_test_message ("Soft fail: Received %x, expected %x", roundtrip_func (script), script);
 869       failed = TRUE;
 870     }
 871   }
 872
 873   g_assert_cmphex (HB_SCRIPT_INVALID, ==, roundtrip_func (HB_SCRIPT_INVALID));
 874
 875   if (failed)
 876     g_test_message ("Some script roundtrip tests failed.  You probably have an old version of one of the libraries used.");
 877 }
 878
 879
 880 static void
 881 test_unicode_normalization (gconstpointer user_data)
 882 {
 883   hb_unicode_funcs_t *uf = (hb_unicode_funcs_t *) user_data;
 884   gunichar a, b, ab;
 885
 886
 887   /* Test compose() */
 888
 889   /* Not composable */
 890   g_assert (!hb_unicode_compose (uf, 0x0041, 0x0042, &ab) && ab == 0);
 891   g_assert (!hb_unicode_compose (uf, 0x0041, 0, &ab) && ab == 0);
 892   g_assert (!hb_unicode_compose (uf, 0x0066, 0x0069, &ab) && ab == 0);
 893
 894   /* Singletons should not compose */
 895   g_assert (!hb_unicode_compose (uf, 0x212B, 0, &ab) && ab == 0);
 896   g_assert (!hb_unicode_compose (uf, 0x00C5, 0, &ab) && ab == 0);
 897   g_assert (!hb_unicode_compose (uf, 0x2126, 0, &ab) && ab == 0);
 898   g_assert (!hb_unicode_compose (uf, 0x03A9, 0, &ab) && ab == 0);
 899
 900   /* Non-starter pairs should not compose */
 901   g_assert (!hb_unicode_compose (uf, 0x0308, 0x0301, &ab) && ab == 0); /* !0x0344 */
 902   g_assert (!hb_unicode_compose (uf, 0x0F71, 0x0F72, &ab) && ab == 0); /* !0x0F73 */
 903
 904   /* Pairs */
 905   g_assert (hb_unicode_compose (uf, 0x0041, 0x030A, &ab) && ab == 0x00C5);
 906   g_assert (hb_unicode_compose (uf, 0x006F, 0x0302, &ab) && ab == 0x00F4);
 907   g_assert (hb_unicode_compose (uf, 0x1E63, 0x0307, &ab) && ab == 0x1E69);
 908   g_assert (hb_unicode_compose (uf, 0x0073, 0x0323, &ab) && ab == 0x1E63);
 909   g_assert (hb_unicode_compose (uf, 0x0064, 0x0307, &ab) && ab == 0x1E0B);
 910   g_assert (hb_unicode_compose (uf, 0x0064, 0x0323, &ab) && ab == 0x1E0D);
 911
 912   /* Hangul */
 913   g_assert (hb_unicode_compose (uf, 0xD4CC, 0x11B6, &ab) && ab == 0xD4DB);
 914   g_assert (hb_unicode_compose (uf, 0x1111, 0x1171, &ab) && ab == 0xD4CC);
 915   g_assert (hb_unicode_compose (uf, 0xCE20, 0x11B8, &ab) && ab == 0xCE31);
 916   g_assert (hb_unicode_compose (uf, 0x110E, 0x1173, &ab) && ab == 0xCE20);
 917
 918   g_assert (!hb_unicode_compose (uf, 0xAC00, 0x11A7, &ab));
 919   g_assert (hb_unicode_compose (uf, 0xAC00, 0x11A8, &ab) && ab == 0xAC01);
 920   g_assert (!hb_unicode_compose (uf, 0xAC01, 0x11A8, &ab));
 921
 922
 923   /* Test decompose() */
 924
 925   /* Not decomposable */
 926   g_assert (!hb_unicode_decompose (uf, 0x0041, &a, &b) && a == 0x0041 && b == 0);
 927   g_assert (!hb_unicode_decompose (uf, 0xFB01, &a, &b) && a == 0xFB01 && b == 0);
 928   g_assert (!hb_unicode_decompose (uf, 0x1F1EF, &a, &b) && a == 0x1F1EF && b == 0);
 929
 930   /* Singletons */
 931   g_assert (hb_unicode_decompose (uf, 0x212B, &a, &b) && a == 0x00C5 && b == 0);
 932   g_assert (hb_unicode_decompose (uf, 0x2126, &a, &b) && a == 0x03A9 && b == 0);
 933
 934   /* Non-starter pairs decompose, but not compose */
 935   g_assert (hb_unicode_decompose (uf, 0x0344, &a, &b) && a == 0x0308 && b == 0x0301);
 936   g_assert (hb_unicode_decompose (uf, 0x0F73, &a, &b) && a == 0x0F71 && b == 0x0F72);
 937
 938   /* Pairs */
 939   g_assert (hb_unicode_decompose (uf, 0x00C5, &a, &b) && a == 0x0041 && b == 0x030A);
 940   g_assert (hb_unicode_decompose (uf, 0x00F4, &a, &b) && a == 0x006F && b == 0x0302);
 941   g_assert (hb_unicode_decompose (uf, 0x1E69, &a, &b) && a == 0x1E63 && b == 0x0307);
 942   g_assert (hb_unicode_decompose (uf, 0x1E63, &a, &b) && a == 0x0073 && b == 0x0323);
 943   g_assert (hb_unicode_decompose (uf, 0x1E0B, &a, &b) && a == 0x0064 && b == 0x0307);
 944   g_assert (hb_unicode_decompose (uf, 0x1E0D, &a, &b) && a == 0x0064 && b == 0x0323);
 945
 946   /* Hangul */
 947   g_assert (hb_unicode_decompose (uf, 0xD4DB, &a, &b) && a == 0xD4CC && b == 0x11B6);
 948   g_assert (hb_unicode_decompose (uf, 0xD4CC, &a, &b) && a == 0x1111 && b == 0x1171);
 949   g_assert (hb_unicode_decompose (uf, 0xCE31, &a, &b) && a == 0xCE20 && b == 0x11B8);
 950   g_assert (hb_unicode_decompose (uf, 0xCE20, &a, &b) && a == 0x110E && b == 0x1173);
 951 }
 952
 953
 954
 955 int
 956 main (int argc, char **argv)
 957 {
 958   hb_test_init (&argc, &argv);
 959
 960   hb_test_add (test_unicode_properties_nil);
 961   hb_test_add (test_unicode_properties_empty);
 962
 963   hb_test_add_data_flavor (hb_unicode_funcs_get_default (),          "default", test_unicode_properties_strict);
 964   hb_test_add_data_flavor (hb_unicode_funcs_get_default (),          "default", test_unicode_normalization);
 965   hb_test_add_data_flavor ((gconstpointer) script_roundtrip_default, "default", test_unicode_script_roundtrip);
 966 #ifdef HAVE_GLIB
 967   hb_test_add_data_flavor (hb_glib_get_unicode_funcs (),             "glib",    test_unicode_properties_lenient);
 968   hb_test_add_data_flavor (hb_glib_get_unicode_funcs (),             "glib",    test_unicode_normalization);
 969   hb_test_add_data_flavor ((gconstpointer) script_roundtrip_glib,    "glib",    test_unicode_script_roundtrip);
 970 #endif
 971 #ifdef HAVE_ICU
 972   hb_test_add_data_flavor (hb_icu_get_unicode_funcs (),              "icu",     test_unicode_properties_lenient);
 973   hb_test_add_data_flavor (hb_icu_get_unicode_funcs (),              "icu",     test_unicode_normalization);
 974   hb_test_add_data_flavor ((gconstpointer) script_roundtrip_icu,     "icu",     test_unicode_script_roundtrip);
 975 #endif
 976
 977   hb_test_add (test_unicode_chainup);
 978
 979   hb_test_add (test_unicode_setters);
 980
 981   hb_test_add_fixture (data_fixture, NULL, test_unicode_subclassing_nil);
 982   hb_test_add_fixture (data_fixture, NULL, test_unicode_subclassing_default);
 983   hb_test_add_fixture (data_fixture, NULL, test_unicode_subclassing_deep);
 984
 985   return hb_test_run ();
 986 }