icuSources/test/letest/cletest.c

   1 /*
   2  *******************************************************************************
   3  *
   4  *   Copyright (C) 1999-2008, International Business Machines
   5  *   Corporation and others.  All Rights Reserved.
   6  *
   7  *******************************************************************************
   8  */
   9
  10 #include "unicode/utypes.h"
  11 #include "unicode/ubidi.h"
  12 #include "unicode/uscript.h"
  13 #include "unicode/ctest.h"
  14
  15 #include "layout/LETypes.h"
  16 #include "layout/LEScripts.h"
  17 #include "layout/loengine.h"
  18
  19 #include "layout/playout.h"
  20 #include "layout/plruns.h"
  21
  22 #include "cfonts.h"
  23
  24 #include "letest.h"
  25
  26 #include "sfnt.h"
  27 #include "xmlreader.h"
  28 #include "putilimp.h" /* for U_FILE_SEP_STRING */
  29
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33
  34 #define CH_COMMA 0x002C
  35
  36 U_CDECL_BEGIN
  37 static void U_CALLCONV ParamTest(void)
  38 {
  39     LEErrorCode status = LE_NO_ERROR;
  40     le_font *font = le_simpleFontOpen(12, &status);
  41     le_engine *engine = le_create(font, arabScriptCode, -1, 0, &status);
  42     LEGlyphID *glyphs    = NULL;
  43     le_int32  *indices   = NULL;
  44     float     *positions = NULL;
  45     le_int32   glyphCount = 0;
  46
  47     float x = 0.0, y = 0.0;
  48         LEUnicode chars[] = {
  49           0x0045, 0x006E, 0x0067, 0x006C, 0x0069, 0x0073, 0x0068, 0x0020, /* "English "                      */
  50           0x0645, 0x0627, 0x0646, 0x062A, 0x0648, 0x0634,                 /* MEM ALIF KAF NOON TEH WAW SHEEN */
  51           0x0020, 0x0074, 0x0065, 0x0078, 0x0074, 0x02E                   /* " text."                        */
  52     };
  53
  54
  55     glyphCount = le_getGlyphCount(engine, &status);
  56     if (glyphCount != 0) {
  57         log_err("Calling getGlyphCount() on an empty layout returned %d.\n", glyphCount);
  58     }
  59
  60     glyphs    = NEW_ARRAY(LEGlyphID, glyphCount + 10);
  61     indices   = NEW_ARRAY(le_int32, glyphCount + 10);
  62     positions = NEW_ARRAY(float, glyphCount + 10);
  63
  64     le_getGlyphs(engine, NULL, &status);
  65
  66     if (status != LE_ILLEGAL_ARGUMENT_ERROR) {
  67         log_err("Calling getGlyphs(NULL, status) did not return LE_ILLEGAL_ARGUMENT_ERROR.\n");
  68     }
  69
  70     status = LE_NO_ERROR;
  71     le_getGlyphs(engine, glyphs, &status);
  72
  73     if (status != LE_NO_LAYOUT_ERROR) {
  74         log_err("Calling getGlyphs(glyphs, status) on an empty layout did not return LE_NO_LAYOUT_ERROR.\n");
  75     }
  76
  77     status = LE_NO_ERROR;
  78     le_getCharIndices(engine, NULL, &status);
  79
  80     if (status != LE_ILLEGAL_ARGUMENT_ERROR) {
  81         log_err("Calling getCharIndices(NULL, status) did not return LE_ILLEGAL_ARGUMENT_ERROR.\n");
  82     }
  83
  84     status = LE_NO_ERROR;
  85     le_getCharIndices(engine, indices, &status);
  86
  87     if (status != LE_NO_LAYOUT_ERROR) {
  88         log_err("Calling getCharIndices(indices, status) on an empty layout did not return LE_NO_LAYOUT_ERROR.\n");
  89     }
  90
  91     status = LE_NO_ERROR;
  92     le_getCharIndicesWithBase(engine, NULL, 1024, &status);
  93
  94     if (status != LE_ILLEGAL_ARGUMENT_ERROR) {
  95         log_err("Calling getCharIndices(NULL, 1024, status) did not return LE_ILLEGAL_ARGUMENT_ERROR.\n");
  96     }
  97
  98     status = LE_NO_ERROR;
  99     le_getCharIndicesWithBase(engine, indices, 1024, &status);
 100
 101     if (status != LE_NO_LAYOUT_ERROR) {
 102         log_err("Calling getCharIndices(indices, 1024, status) on an empty layout did not return LE_NO_LAYOUT_ERROR.\n");
 103     }
 104
 105     status = LE_NO_ERROR;
 106     le_getGlyphPositions(engine, NULL, &status);
 107
 108     if (status != LE_ILLEGAL_ARGUMENT_ERROR) {
 109         log_err("Calling getGlyphPositions(NULL, status) did not return LE_ILLEGAL_ARGUMENT_ERROR.\n");
 110     }
 111
 112     status = LE_NO_ERROR;
 113     le_getGlyphPositions(engine, positions, &status);
 114
 115     if (status != LE_NO_LAYOUT_ERROR) {
 116         log_err("Calling getGlyphPositions(positions, status) on an empty layout did not return LE_NO_LAYOUT_ERROR.\n");
 117     }
 118
 119     DELETE_ARRAY(positions);
 120     DELETE_ARRAY(indices);
 121     DELETE_ARRAY(glyphs);
 122
 123     status = LE_NO_ERROR;
 124     glyphCount = le_layoutChars(engine, NULL, 0, 0, 0, FALSE, 0.0, 0.0, &status);
 125
 126     if (status != LE_ILLEGAL_ARGUMENT_ERROR) {
 127         log_err("Calling layoutChars(NULL, 0, 0, 0, FALSE, 0.0, 0.0, status) did not fail w/ LE_ILLEGAL_ARGUMENT_ERROR.\n");
 128     }
 129
 130     status = LE_NO_ERROR;
 131     glyphCount = le_layoutChars(engine, chars, -1, 6, 20, TRUE, 0.0, 0.0, &status);
 132
 133     if (status != LE_ILLEGAL_ARGUMENT_ERROR) {
 134         log_err("Calling layoutChars(chars, -1, 6, 20, TRUE, 0.0, 0.0, status) did not fail w/ LE_ILLEGAL_ARGUMENT_ERROR.\n");
 135     }
 136
 137     status = LE_NO_ERROR;
 138     glyphCount = le_layoutChars(engine, chars, 8, -1, 20, TRUE, 0.0, 0.0, &status);
 139
 140     if (status != LE_ILLEGAL_ARGUMENT_ERROR) {
 141         log_err("Calling layoutChars(chars, 8, -1, 20, TRUE, 0.0, 0.0, status) did not fail w/ LE_ILLEGAL_ARGUMENT_ERROR.\n");
 142     }
 143
 144     status = LE_NO_ERROR;
 145     glyphCount = le_layoutChars(engine, chars, 8, 6, -1, TRUE, 0.0, 0.0, &status);
 146
 147     if (status != LE_ILLEGAL_ARGUMENT_ERROR) {
 148         log_err("Calling layoutChars((chars, 8, 6, -1, TRUE, 0.0, 0.0, status) did not fail w/ LE_ILLEGAL_ARGUMENT_ERROR.\n");
 149     }
 150
 151     status = LE_NO_ERROR;
 152     glyphCount = le_layoutChars(engine, chars, 8, 6, 10, TRUE, 0.0, 0.0, &status);
 153
 154     if (status != LE_ILLEGAL_ARGUMENT_ERROR) {
 155         log_err("Calling layoutChars(chars, 8, 6, 10, TRUE, 0.0, 0.0, status) did not fail w/ LE_ILLEGAL_ARGUMENT_ERROR.\n");
 156     }
 157
 158     status = LE_NO_ERROR;
 159     glyphCount = le_layoutChars(engine, chars, 8, 6, 20, TRUE, 0.0, 0.0, &status);
 160
 161     if (LE_FAILURE(status)) {
 162         log_err("Calling layoutChars(chars, 8, 6, 20, TRUE, 0.0, 0.0, status) failed.\n");
 163         goto bail;
 164     }
 165
 166     le_getGlyphPosition(engine, -1, &x, &y, &status);
 167
 168     if (status != LE_INDEX_OUT_OF_BOUNDS_ERROR) {
 169         log_err("Calling getGlyphPosition(-1, x, y, status) did not fail w/ LE_INDEX_OUT_OF_BOUNDS_ERROR.\n");
 170     }
 171
 172     status = LE_NO_ERROR;
 173     le_getGlyphPosition(engine, glyphCount + 1, &x, &y, &status);
 174
 175     if (status != LE_INDEX_OUT_OF_BOUNDS_ERROR) {
 176         log_err("Calling getGlyphPosition(glyphCount + 1, x, y, status) did not fail w/ LE_INDEX_OUT_OF_BOUNDS_ERROR.\n");
 177     }
 178
 179 bail:
 180     le_close(engine);
 181     le_fontClose(font);
 182 }
 183 U_CDECL_END
 184
 185 U_CDECL_BEGIN
 186 static void U_CALLCONV FactoryTest(void)
 187 {
 188     LEErrorCode status = LE_NO_ERROR;
 189     le_font *font = le_simpleFontOpen(12, &status);
 190     le_engine *engine = NULL;
 191         le_int32 scriptCode;
 192
 193     for(scriptCode = 0; scriptCode < scriptCodeCount; scriptCode += 1) {
 194         status = LE_NO_ERROR;
 195         engine = le_create(font, scriptCode, -1, 0, &status);
 196
 197         if (LE_FAILURE(status)) {
 198             log_err("Could not create a LayoutEngine for script \'%s\'.\n", uscript_getShortName((UScriptCode)scriptCode));
 199         }
 200
 201         le_close(engine);
 202     }
 203
 204     le_fontClose(font);
 205 }
 206 U_CDECL_END
 207
 208 U_CDECL_BEGIN
 209 static void U_CALLCONV AccessTest(void)
 210 {
 211     LEErrorCode status = LE_NO_ERROR;
 212     le_font *font = le_simpleFontOpen(12, &status);
 213     le_engine *engine =le_create(font, arabScriptCode, -1, 0, &status);
 214     le_int32 glyphCount;
 215     LEGlyphID glyphs[6];
 216     le_int32 biasedIndices[6], indices[6], glyph;
 217     float positions[6 * 2 + 2];
 218     LEUnicode chars[] = {
 219       0x0045, 0x006E, 0x0067, 0x006C, 0x0069, 0x0073, 0x0068, 0x0020, /* "English "                      */
 220       0x0645, 0x0627, 0x0646, 0x062A, 0x0648, 0x0634,                 /* MEM ALIF KAF NOON TEH WAW SHEEN */
 221       0x0020, 0x0074, 0x0065, 0x0078, 0x0074, 0x02E                   /* " text."                        */
 222     };
 223
 224     if (LE_FAILURE(status)) {
 225         log_err("Could not create LayoutEngine.\n");
 226         goto bail;
 227     }
 228
 229     glyphCount = le_layoutChars(engine, chars, 8, 6, 20, TRUE, 0.0, 0.0, &status);
 230
 231     if (LE_FAILURE(status) || glyphCount != 6) {
 232         log_err("layoutChars(chars, 8, 6, 20, TRUE, 0.0, 0.0, status) failed.\n");
 233         goto bail;
 234     }
 235
 236     le_getGlyphs(engine, glyphs, &status);
 237     le_getCharIndices(engine, indices, &status);
 238     le_getGlyphPositions(engine, positions, &status);
 239
 240     if (LE_FAILURE(status)) {
 241         log_err("Could not get glyph, indices and position arrays.\n");
 242         goto bail;
 243     }
 244
 245     status = LE_NO_ERROR;
 246     le_getCharIndicesWithBase(engine, biasedIndices, 1024, &status);
 247
 248     if (LE_FAILURE(status)) {
 249         log_err("getCharIndices(biasedIndices, 1024, status) failed.\n");
 250     } else {
 251         for (glyph = 0; glyph < glyphCount; glyph += 1) {
 252             if (biasedIndices[glyph] != (indices[glyph] + 1024)) {
 253                 log_err("biasedIndices[%d] != indices[%d] + 1024: %8X, %8X\n",
 254                     glyph, glyph, biasedIndices[glyph], indices[glyph]);
 255                 break;
 256             }
 257         }
 258     }
 259
 260     status = LE_NO_ERROR;
 261     for (glyph = 0; glyph <= glyphCount; glyph += 1) {
 262         float x = 0.0, y = 0.0;
 263
 264         le_getGlyphPosition(engine, glyph, &x, &y, &status);
 265
 266         if (LE_FAILURE(status)) {
 267             log_err("getGlyphPosition(%d, x, y, status) failed.\n", glyph);
 268             break;
 269         }
 270
 271         if (x != positions[glyph*2] || y != positions[glyph*2 + 1]) {
 272             log_err("getGlyphPosition(%d, x, y, status) returned bad position: (%f, %f) != (%f, %f)\n",
 273                 glyph, x, y, positions[glyph*2], positions[glyph*2 + 1]);
 274             break;
 275         }
 276     }
 277
 278 bail:
 279     le_close(engine);
 280     le_fontClose(font);
 281 }
 282 U_CDECL_END
 283
 284 static le_bool compareResults(const char *testID, TestResult *expected, TestResult *actual)
 285 {
 286     le_int32 i;
 287
 288     /* NOTE: we'll stop on the first failure 'cause once there's one error, it may cascade... */
 289     if (actual->glyphCount != expected->glyphCount) {
 290         log_err("Test %s: incorrect glyph count: exptected %d, got %d\n",
 291             testID, expected->glyphCount, actual->glyphCount);
 292         return FALSE;
 293     }
 294
 295     for (i = 0; i < actual->glyphCount; i += 1) {
 296         if (actual->glyphs[i] != expected->glyphs[i]) {
 297             log_err("Test %s: incorrect id for glyph %d: expected %4X, got %4X\n",
 298                 testID, i, expected->glyphs[i], actual->glyphs[i]);
 299             return FALSE;
 300         }
 301     }
 302
 303     for (i = 0; i < actual->glyphCount; i += 1) {
 304         if (actual->indices[i] != expected->indices[i]) {
 305             log_err("Test %s: incorrect index for glyph %d: expected %8X, got %8X\n",
 306                 testID, i, expected->indices[i], actual->indices[i]);
 307             return FALSE;
 308         }
 309     }
 310
 311     for (i = 0; i <= actual->glyphCount; i += 1) {
 312         double xError = uprv_fabs(actual->positions[i * 2] - expected->positions[i * 2]);
 313         double yError = uprv_fabs(actual->positions[i * 2 + 1] - expected->positions[i * 2 + 1]);
 314
 315         if (xError > 0.0001) {
 316             log_err("Test %s: incorrect x position for glyph %d: expected %f, got %f\n",
 317                 testID, i, expected->positions[i * 2], actual->positions[i * 2]);
 318             return FALSE;
 319         }
 320
 321         if (yError < 0) {
 322             yError = -yError;
 323         }
 324
 325         if (yError > 0.0001) {
 326             log_err("Test %s: incorrect y position for glyph %d: expected %f, got %f\n",
 327                 testID, i, expected->positions[i * 2 + 1], actual->positions[i * 2 + 1]);
 328             return FALSE;
 329         }
 330     }
 331
 332     return TRUE;
 333 }
 334
 335 static void checkFontVersion(le_font *font, const char *testVersionString,
 336                              le_uint32 testChecksum, const char *testID)
 337 {
 338     le_uint32 fontChecksum = le_getFontChecksum(font);
 339
 340     if (fontChecksum != testChecksum) {
 341         const char *fontVersionString = le_getNameString(font, NAME_VERSION_STRING,
 342             PLATFORM_MACINTOSH, MACINTOSH_ROMAN, MACINTOSH_ENGLISH);
 343         const LEUnicode16 *uFontVersionString = NULL;
 344
 345         if (fontVersionString == NULL) {
 346             uFontVersionString = le_getUnicodeNameString(font, NAME_VERSION_STRING,
 347                 PLATFORM_MICROSOFT, MICROSOFT_UNICODE_BMP, MICROSOFT_ENGLISH);
 348         }
 349
 350         log_info("Test %s: this may not be the same font used to generate the test data.\n", testID);
 351
 352         if (uFontVersionString != NULL) {
 353             log_info("Your font's version string is \"%S\"\n", uFontVersionString);
 354             le_deleteUnicodeNameString(font, uFontVersionString);
 355         } else {
 356             log_info("Your font's version string is \"%s\"\n", fontVersionString);
 357             le_deleteNameString(font, fontVersionString);
 358         }
 359
 360         log_info("The expected version string is \"%s\"\n", testVersionString);
 361         log_info("If you see errors, they may be due to the version of the font you're using.\n");
 362     }
 363 }
 364
 365 /* Returns the path to icu/source/test/testdata/ */
 366 static const char *getSourceTestData() {
 367 #ifdef U_TOPSRCDIR
 368     const char *srcDataDir = U_TOPSRCDIR U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING;
 369 #else
 370     const char *srcDataDir = ".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING;
 371     FILE *f = fopen(".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING"rbbitst.txt", "r");
 372
 373     if (f != NULL) {
 374         /* We're in icu/source/test/letest/ */
 375         fclose(f);
 376     } else {
 377         /* We're in icu/source/test/letest/(Debug|Release) */
 378         srcDataDir = ".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING".."U_FILE_SEP_STRING"test"U_FILE_SEP_STRING"testdata"U_FILE_SEP_STRING;
 379     }
 380 #endif
 381
 382     return srcDataDir;
 383 }
 384
 385 static const char *getPath(char buffer[2048], const char *filename) {
 386     const char *testDataDirectory = getSourceTestData();
 387
 388     strcpy(buffer, testDataDirectory);
 389     strcat(buffer, filename);
 390
 391     return buffer;
 392 }
 393
 394 static le_font *openFont(const char *fontName, const char *checksum, const char *version, const char *testID)
 395 {
 396     char path[2048];
 397     le_font *font;
 398     LEErrorCode fontStatus = LE_NO_ERROR;
 399
 400         if (fontName != NULL) {
 401                 font = le_portableFontOpen(getPath(path, fontName), 12, &fontStatus);
 402
 403                 if (LE_FAILURE(fontStatus)) {
 404                         log_info("Test %s: can't open font %s - test skipped.\n", testID, fontName);
 405                         le_fontClose(font);
 406                         return NULL;
 407                 } else {
 408                         le_uint32 cksum = 0;
 409
 410                         sscanf(checksum, "%x", &cksum);
 411
 412                         checkFontVersion(font, version, cksum, testID);
 413                 }
 414         } else {
 415                 font = le_simpleFontOpen(12, &fontStatus);
 416         }
 417
 418     return font;
 419 }
 420
 421 static le_bool getRTL(const LEUnicode *text, le_int32 charCount)
 422 {
 423     UBiDiLevel level;
 424     le_int32 limit = -1;
 425     UErrorCode status = U_ZERO_ERROR;
 426     UBiDi *ubidi = ubidi_openSized(charCount, 0, &status);
 427
 428     ubidi_setPara(ubidi, text, charCount, UBIDI_DEFAULT_LTR, NULL, &status);
 429
 430     /* TODO: Should check that there's only a single logical run... */
 431     ubidi_getLogicalRun(ubidi, 0, &limit, &level);
 432
 433     ubidi_close(ubidi);
 434
 435     return level & 1;
 436 }
 437
 438 static void doTestCase (const char *testID,
 439                                  const char *fontName,
 440                                  const char *fontVersion,
 441                                  const char *fontChecksum,
 442                                  le_int32 scriptCode,
 443                                  le_int32 languageCode,
 444                                  const LEUnicode *text,
 445                                  le_int32 charCount,
 446                                  TestResult *expected)
 447 {
 448         LEErrorCode status = LE_NO_ERROR;
 449         le_engine *engine;
 450         le_font *font = openFont(fontName, fontChecksum, fontVersion, testID);
 451         le_int32 typoFlags = 3; /* kerning + ligatures */
 452         TestResult actual;
 453
 454         if (font == NULL) {
 455                 /* error message already printed. */
 456                 return;
 457         }
 458
 459         if (fontName == NULL) {
 460                 typoFlags |= 0x80000000L;  /* use CharSubstitutionFilter... */
 461         }
 462
 463     engine = le_create(font, scriptCode, languageCode, typoFlags, &status);
 464
 465     if (LE_FAILURE(status)) {
 466         log_err("Test %s: could not create a LayoutEngine.\n", testID);
 467         goto free_expected;
 468     }
 469
 470     actual.glyphCount = le_layoutChars(engine, text, 0, charCount, charCount, getRTL(text, charCount), 0, 0, &status);
 471
 472     actual.glyphs    = NEW_ARRAY(LEGlyphID, actual.glyphCount);
 473     actual.indices   = NEW_ARRAY(le_int32, actual.glyphCount);
 474     actual.positions = NEW_ARRAY(float, actual.glyphCount * 2 + 2);
 475
 476     le_getGlyphs(engine, actual.glyphs, &status);
 477     le_getCharIndices(engine, actual.indices, &status);
 478     le_getGlyphPositions(engine, actual.positions, &status);
 479
 480     compareResults(testID, expected, &actual);
 481
 482     DELETE_ARRAY(actual.positions);
 483     DELETE_ARRAY(actual.indices);
 484     DELETE_ARRAY(actual.glyphs);
 485
 486     le_close(engine);
 487
 488 free_expected:
 489     le_fontClose(font);
 490 }
 491
 492 static void U_CALLCONV DataDrivenTest(void)
 493 {
 494     char path[2048];
 495     const char *testFilePath = getPath(path, "letest.xml");
 496
 497         readTestFile(testFilePath, doTestCase);
 498 }
 499
 500 /*
 501  * From ticket:5923:
 502  *
 503  * Build a paragraph that contains a mixture of left to right and right to left text.
 504  * Break it into multiple lines and make sure that the glyphToCharMap for run in each
 505  * line is correct.
 506  *
 507  * Note: it might be a good idea to also check the glyphs and positions for each run,
 508  * that we get the expected number of runs per line and that the line breaks are where
 509  * we expect them to be. Really, it would be a good idea to make a whole test suite
 510  * for pl_paragraph.
 511  */
 512 static void U_CALLCONV GlyphToCharTest(void)
 513 {
 514     LEErrorCode status = LE_NO_ERROR;
 515     le_font *font;
 516     pl_fontRuns *fontRuns;
 517     pl_paragraph *paragraph;
 518     const pl_line *line;
 519     /*
 520      * This is the same text that's in <icu>/source/samples/layout/Sample.txt
 521      */
 522     LEUnicode chars[] = {
 523         /*BOM*/ 0x0054, 0x0068, 0x0065, 0x0020, 0x004c, 0x0061, 0x0079,
 524         0x006f, 0x0075, 0x0074, 0x0045, 0x006e, 0x0067, 0x0069, 0x006e,
 525         0x0065, 0x0020, 0x0064, 0x006f, 0x0065, 0x0073, 0x0020, 0x0061,
 526         0x006c, 0x006c, 0x0020, 0x0074, 0x0068, 0x0065, 0x0020, 0x0077,
 527         0x006f, 0x0072, 0x006b, 0x0020, 0x006e, 0x0065, 0x0063, 0x0065,
 528         0x0073, 0x0073, 0x0061, 0x0072, 0x0079, 0x0020, 0x0074, 0x006f,
 529         0x0020, 0x0064, 0x0069, 0x0073, 0x0070, 0x006c, 0x0061, 0x0079,
 530         0x0020, 0x0055, 0x006e, 0x0069, 0x0063, 0x006f, 0x0064, 0x0065,
 531         0x0020, 0x0074, 0x0065, 0x0078, 0x0074, 0x0020, 0x0077, 0x0072,
 532         0x0069, 0x0074, 0x0074, 0x0065, 0x006e, 0x0020, 0x0069, 0x006e,
 533         0x0020, 0x006c, 0x0061, 0x006e, 0x0067, 0x0075, 0x0061, 0x0067,
 534         0x0065, 0x0073, 0x0020, 0x0077, 0x0069, 0x0074, 0x0068, 0x0020,
 535         0x0063, 0x006f, 0x006d, 0x0070, 0x006c, 0x0065, 0x0078, 0x0020,
 536         0x0077, 0x0072, 0x0069, 0x0074, 0x0069, 0x006e, 0x0067, 0x0020,
 537         0x0073, 0x0079, 0x0073, 0x0074, 0x0065, 0x006d, 0x0073, 0x0020,
 538         0x0073, 0x0075, 0x0063, 0x0068, 0x0020, 0x0061, 0x0073, 0x0020,
 539         0x0048, 0x0069, 0x006e, 0x0064, 0x0069, 0x0020, 0x0028, 0x0939,
 540         0x093f, 0x0928, 0x094d, 0x0926, 0x0940, 0x0029, 0x0020, 0x0054,
 541         0x0068, 0x0061, 0x0069, 0x0020, 0x0028, 0x0e44, 0x0e17, 0x0e22,
 542         0x0029, 0x0020, 0x0061, 0x006e, 0x0064, 0x0020, 0x0041, 0x0072,
 543         0x0061, 0x0062, 0x0069, 0x0063, 0x0020, 0x0028, 0x0627, 0x0644,
 544         0x0639, 0x0631, 0x0628, 0x064a, 0x0629, 0x0029, 0x002e, 0x0020,
 545         0x0048, 0x0065, 0x0072, 0x0065, 0x0027, 0x0073, 0x0020, 0x0061,
 546         0x0020, 0x0073, 0x0061, 0x006d, 0x0070, 0x006c, 0x0065, 0x0020,
 547         0x006f, 0x0066, 0x0020, 0x0073, 0x006f, 0x006d, 0x0065, 0x0020,
 548         0x0074, 0x0065, 0x0078, 0x0074, 0x0020, 0x0077, 0x0072, 0x0069,
 549         0x0074, 0x0074, 0x0065, 0x006e, 0x0020, 0x0069, 0x006e, 0x0020,
 550         0x0053, 0x0061, 0x006e, 0x0073, 0x006b, 0x0072, 0x0069, 0x0074,
 551         0x003a, 0x0020, 0x0936, 0x094d, 0x0930, 0x0940, 0x092e, 0x0926,
 552         0x094d, 0x0020, 0x092d, 0x0917, 0x0935, 0x0926, 0x094d, 0x0917,
 553         0x0940, 0x0924, 0x093e, 0x0020, 0x0905, 0x0927, 0x094d, 0x092f,
 554         0x093e, 0x092f, 0x0020, 0x0905, 0x0930, 0x094d, 0x091c, 0x0941,
 555         0x0928, 0x0020, 0x0935, 0x093f, 0x0937, 0x093e, 0x0926, 0x0020,
 556         0x092f, 0x094b, 0x0917, 0x0020, 0x0927, 0x0943, 0x0924, 0x0930,
 557         0x093e, 0x0937, 0x094d, 0x091f, 0x094d, 0x0930, 0x0020, 0x0909,
 558         0x0935, 0x093e, 0x091a, 0x0964, 0x0020, 0x0927, 0x0930, 0x094d,
 559         0x092e, 0x0915, 0x094d, 0x0937, 0x0947, 0x0924, 0x094d, 0x0930,
 560         0x0947, 0x0020, 0x0915, 0x0941, 0x0930, 0x0941, 0x0915, 0x094d,
 561         0x0937, 0x0947, 0x0924, 0x094d, 0x0930, 0x0947, 0x0020, 0x0938,
 562         0x092e, 0x0935, 0x0947, 0x0924, 0x093e, 0x0020, 0x092f, 0x0941,
 563         0x092f, 0x0941, 0x0924, 0x094d, 0x0938, 0x0935, 0x0903, 0x0020,
 564         0x092e, 0x093e, 0x092e, 0x0915, 0x093e, 0x0903, 0x0020, 0x092a,
 565         0x093e, 0x0923, 0x094d, 0x0921, 0x0935, 0x093e, 0x0936, 0x094d,
 566         0x091a, 0x0948, 0x0935, 0x0020, 0x0915, 0x093f, 0x092e, 0x0915,
 567         0x0941, 0x0930, 0x094d, 0x0935, 0x0924, 0x0020, 0x0938, 0x0902,
 568         0x091c, 0x092f, 0x0020, 0x0048, 0x0065, 0x0072, 0x0065, 0x0027,
 569         0x0073, 0x0020, 0x0061, 0x0020, 0x0073, 0x0061, 0x006d, 0x0070,
 570         0x006c, 0x0065, 0x0020, 0x006f, 0x0066, 0x0020, 0x0073, 0x006f,
 571         0x006d, 0x0065, 0x0020, 0x0074, 0x0065, 0x0078, 0x0074, 0x0020,
 572         0x0077, 0x0072, 0x0069, 0x0074, 0x0074, 0x0065, 0x006e, 0x0020,
 573         0x0069, 0x006e, 0x0020, 0x0041, 0x0072, 0x0061, 0x0062, 0x0069,
 574         0x0063, 0x003a, 0x0020, 0x0623, 0x0633, 0x0627, 0x0633, 0x064b,
 575         0x0627, 0x060c, 0x0020, 0x062a, 0x062a, 0x0639, 0x0627, 0x0645,
 576         0x0644, 0x0020, 0x0627, 0x0644, 0x062d, 0x0648, 0x0627, 0x0633,
 577         0x064a, 0x0628, 0x0020, 0x0641, 0x0642, 0x0637, 0x0020, 0x0645,
 578         0x0639, 0x0020, 0x0627, 0x0644, 0x0623, 0x0631, 0x0642, 0x0627,
 579         0x0645, 0x060c, 0x0020, 0x0648, 0x062a, 0x0642, 0x0648, 0x0645,
 580         0x0020, 0x0628, 0x062a, 0x062e, 0x0632, 0x064a, 0x0646, 0x0020,
 581         0x0627, 0x0644, 0x0623, 0x062d, 0x0631, 0x0641, 0x0020, 0x0648,
 582         0x0627, 0x0644, 0x0645, 0x062d, 0x0627, 0x0631, 0x0641, 0x0020,
 583         0x0627, 0x0644, 0x0623, 0x062e, 0x0631, 0x0649, 0x0020, 0x0628,
 584         0x0639, 0x062f, 0x0020, 0x0623, 0x0646, 0x0020, 0x062a, 0x064f,
 585         0x0639, 0x0637, 0x064a, 0x0020, 0x0631, 0x0642, 0x0645, 0x0627,
 586         0x0020, 0x0645, 0x0639, 0x064a, 0x0646, 0x0627, 0x0020, 0x0644,
 587         0x0643, 0x0644, 0x0020, 0x0648, 0x0627, 0x062d, 0x062f, 0x0020,
 588         0x0645, 0x0646, 0x0647, 0x0627, 0x002e, 0x0020, 0x0648, 0x0642,
 589         0x0628, 0x0644, 0x0020, 0x0627, 0x062e, 0x062a, 0x0631, 0x0627,
 590         0x0639, 0x0020, 0x0022, 0x064a, 0x0648, 0x0646, 0x0650, 0x0643,
 591         0x0648, 0x062f, 0x0022, 0x060c, 0x0020, 0x0643, 0x0627, 0x0646,
 592         0x0020, 0x0647, 0x0646, 0x0627, 0x0643, 0x0020, 0x0645, 0x0626,
 593         0x0627, 0x062a, 0x0020, 0x0627, 0x0644, 0x0623, 0x0646, 0x0638,
 594         0x0645, 0x0629, 0x0020, 0x0644, 0x0644, 0x062a, 0x0634, 0x0641,
 595         0x064a, 0x0631, 0x0020, 0x0648, 0x062a, 0x062e, 0x0635, 0x064a,
 596         0x0635, 0x0020, 0x0647, 0x0630, 0x0647, 0x0020, 0x0627, 0x0644,
 597         0x0623, 0x0631, 0x0642, 0x0627, 0x0645, 0x0020, 0x0644, 0x0644,
 598         0x0645, 0x062d, 0x0627, 0x0631, 0x0641, 0x060c, 0x0020, 0x0648,
 599         0x0644, 0x0645, 0x0020, 0x064a, 0x0648, 0x062c, 0x062f, 0x0020,
 600         0x0646, 0x0638, 0x0627, 0x0645, 0x0020, 0x062a, 0x0634, 0x0641,
 601         0x064a, 0x0631, 0x0020, 0x0648, 0x0627, 0x062d, 0x062f, 0x0020,
 602         0x064a, 0x062d, 0x062a, 0x0648, 0x064a, 0x0020, 0x0639, 0x0644,
 603         0x0649, 0x0020, 0x062c, 0x0645, 0x064a, 0x0639, 0x0020, 0x0627,
 604         0x0644, 0x0645, 0x062d, 0x0627, 0x0631, 0x0641, 0x0020, 0x0627,
 605         0x0644, 0x0636, 0x0631, 0x0648, 0x0631, 0x064a, 0x0629, 0x0020,
 606         0x0061, 0x006e, 0x0064, 0x0020, 0x0068, 0x0065, 0x0072, 0x0065,
 607         0x0027, 0x0073, 0x0020, 0x0061, 0x0020, 0x0073, 0x0061, 0x006d,
 608         0x0070, 0x006c, 0x0065, 0x0020, 0x006f, 0x0066, 0x0020, 0x0073,
 609         0x006f, 0x006d, 0x0065, 0x0020, 0x0074, 0x0065, 0x0078, 0x0074,
 610         0x0020, 0x0077, 0x0072, 0x0069, 0x0074, 0x0074, 0x0065, 0x006e,
 611         0x0020, 0x0069, 0x006e, 0x0020, 0x0054, 0x0068, 0x0061, 0x0069,
 612         0x003a, 0x0020, 0x0e1a, 0x0e17, 0x0e17, 0x0e35, 0x0e48, 0x0e51,
 613         0x0e1e, 0x0e32, 0x0e22, 0x0e38, 0x0e44, 0x0e0b, 0x0e42, 0x0e04,
 614         0x0e25, 0x0e19, 0x0e42, 0x0e14, 0x0e42, 0x0e23, 0x0e18, 0x0e35,
 615         0x0e2d, 0x0e32, 0x0e28, 0x0e31, 0x0e22, 0x0e2d, 0x0e22, 0x0e39,
 616         0x0e48, 0x0e17, 0x0e48, 0x0e32, 0x0e21, 0x0e01, 0x0e25, 0x0e32,
 617         0x0e07, 0x0e17, 0x0e38, 0x0e48, 0x0e07, 0x0e43, 0x0e2b, 0x0e0d,
 618         0x0e48, 0x0e43, 0x0e19, 0x0e41, 0x0e04, 0x0e19, 0x0e0b, 0x0e31,
 619         0x0e2a, 0x0e01, 0x0e31, 0x0e1a, 0x0e25, 0x0e38, 0x0e07, 0x0e40,
 620         0x0e2e, 0x0e19, 0x0e23, 0x0e35, 0x0e0a, 0x0e32, 0x0e27, 0x0e44,
 621         0x0e23, 0x0e48, 0x0e41, 0x0e25, 0x0e30, 0x0e1b, 0x0e49, 0x0e32,
 622         0x0e40, 0x0e2d, 0x0e47, 0x0e21, 0x0e20, 0x0e23, 0x0e23, 0x0e22,
 623         0x0e32, 0x0e0a, 0x0e32, 0x0e27, 0x0e44, 0x0e23, 0x0e48, 0x0e1a,
 624         0x0e49, 0x0e32, 0x0e19, 0x0e02, 0x0e2d, 0x0e07, 0x0e1e, 0x0e27,
 625         0x0e01, 0x0e40, 0x0e02, 0x0e32, 0x0e2b, 0x0e25, 0x0e31, 0x0e07,
 626         0x0e40, 0x0e25, 0x0e47, 0x0e01, 0x0e40, 0x0e1e, 0x0e23, 0x0e32,
 627         0x0e30, 0x0e44, 0x0e21, 0x0e49, 0x0e2a, 0x0e23, 0x0e49, 0x0e32,
 628         0x0e07, 0x0e1a, 0x0e49, 0x0e32, 0x0e19, 0x0e15, 0x0e49, 0x0e2d,
 629         0x0e07, 0x0e02, 0x0e19, 0x0e21, 0x0e32, 0x0e14, 0x0e49, 0x0e27,
 630         0x0e22, 0x0e40, 0x0e01, 0x0e27, 0x0e35, 0x0e22, 0x0e19, 0x0e40,
 631         0x0e1b, 0x0e47, 0x0e19, 0x0e23, 0x0e30, 0x0e22, 0x0e30, 0x0e17,
 632         0x0e32, 0x0e07, 0x0e2b, 0x0e25, 0x0e32, 0x0e22, 0x0e44, 0x0e21,
 633         0x0e25, 0x0e4c
 634     };
 635     le_int32 charCount = LE_ARRAY_SIZE(chars);
 636     le_int32 charIndex = 0, lineNumber = 1;
 637     le_int32 run, i;
 638     const float lineWidth = 600;
 639
 640     font = le_simpleFontOpen(12, &status);
 641
 642     if (LE_FAILURE(status)) {
 643         log_err("le_simpleFontOpen(12, &status) failed");
 644         goto finish;
 645     }
 646
 647     fontRuns = pl_openEmptyFontRuns(0);
 648     pl_addFontRun(fontRuns, font, charCount);
 649
 650     paragraph = pl_create(chars, charCount, fontRuns, NULL, NULL, NULL, 0, FALSE, &status);
 651
 652     pl_closeFontRuns(fontRuns);
 653
 654     if (LE_FAILURE(status)) {
 655         log_err("pl_create failed.");
 656         goto close_font;
 657     }
 658
 659     pl_reflow(paragraph);
 660     while ((line = pl_nextLine(paragraph, lineWidth)) != NULL) {
 661         le_int32 runCount = pl_countLineRuns(line);
 662
 663         for(run = 0; run < runCount; run += 1) {
 664             const pl_visualRun *visualRun = pl_getLineVisualRun(line, run);
 665             const le_int32 glyphCount = pl_getVisualRunGlyphCount(visualRun);
 666             const le_int32 *glyphToCharMap = pl_getVisualRunGlyphToCharMap(visualRun);
 667
 668             if (pl_getVisualRunDirection(visualRun) == UBIDI_RTL) {
 669                 /*
 670                  * For a right to left run, make sure that the character indices
 671                  * increase from the right most glyph to the left most glyph. If
 672                  * there are any one to many glyph substitutions, we might get several
 673                  * glyphs in a row with the same character index.
 674                  */
 675                 for(i = glyphCount - 1; i >= 0; i -= 1) {
 676                     le_int32 ix = glyphToCharMap[i];
 677
 678                     if (ix != charIndex) {
 679                         if (ix != charIndex - 1) {
 680                             log_err("Bad glyph to char index for glyph %d on line %d: expected %d, got %d\n",
 681                                 i, lineNumber, charIndex, ix);
 682                             goto close_paragraph; /* once there's one error, we can't count on anything else... */
 683                         }
 684                     } else {
 685                         charIndex += 1;
 686                     }
 687                 }
 688             } else {
 689                 /*
 690                  * We can't just check the order of the character indices
 691                  * for left to right runs because Indic text might have been
 692                  * reordered. What we can do is find the minimum and maximum
 693                  * character indices in the run and make sure that the minimum
 694                  * is equal to charIndex and then advance charIndex to the maximum.
 695                  */
 696                 le_int32 minIndex = 0x7FFFFFFF, maxIndex = -1;
 697
 698                 for(i = 0; i < glyphCount; i += 1) {
 699                     le_int32 ix = glyphToCharMap[i];
 700
 701                     if (ix > maxIndex) {
 702                         maxIndex = ix;
 703                     }
 704
 705                     if (ix < minIndex) {
 706                         minIndex = ix;
 707                     }
 708                 }
 709
 710                 if (minIndex != charIndex) {
 711                     log_err("Bad minIndex for run %d on line %d: expected %d, got %d\n",
 712                         run, lineNumber, charIndex, minIndex);
 713                     goto close_paragraph; /* once there's one error, we can't count on anything else... */
 714                 }
 715
 716                 charIndex = maxIndex + 1;
 717             }
 718         }
 719
 720         lineNumber += 1;
 721     }
 722
 723 close_paragraph:
 724     pl_close(paragraph);
 725
 726 close_font:
 727     le_fontClose(font);
 728
 729 finish:
 730     return;
 731 }
 732
 733 U_CFUNC void addCTests(TestNode **root)
 734 {
 735     addTest(root, &ParamTest,       "c_api/ParameterTest");
 736     addTest(root, &FactoryTest,     "c_api/FactoryTest");
 737     addTest(root, &AccessTest,      "c_layout/AccessTest");
 738     addTest(root, &DataDrivenTest,  "c_layout/DataDrivenTest");
 739     addTest(root, &GlyphToCharTest, "c_paragraph/GlyphToCharTest");
 740 }
 741
 742