1 /* 2 ******************************************************************************* 3 * 4 * Copyright (C) 1999-2014, 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 #if !UCONFIG_NO_BREAK_ITERATION 515 LEErrorCode status = LE_NO_ERROR; 516 le_font *font; 517 pl_fontRuns *fontRuns; 518 pl_paragraph *paragraph; 519 const pl_line *line; 520 /* 521 * This is the same text that's in <icu>/source/samples/layout/Sample.txt 522 */ 523 LEUnicode chars[] = { 524 /*BOM*/ 0x0054, 0x0068, 0x0065, 0x0020, 0x004c, 0x0061, 0x0079, 525 0x006f, 0x0075, 0x0074, 0x0045, 0x006e, 0x0067, 0x0069, 0x006e, 526 0x0065, 0x0020, 0x0064, 0x006f, 0x0065, 0x0073, 0x0020, 0x0061, 527 0x006c, 0x006c, 0x0020, 0x0074, 0x0068, 0x0065, 0x0020, 0x0077, 528 0x006f, 0x0072, 0x006b, 0x0020, 0x006e, 0x0065, 0x0063, 0x0065, 529 0x0073, 0x0073, 0x0061, 0x0072, 0x0079, 0x0020, 0x0074, 0x006f, 530 0x0020, 0x0064, 0x0069, 0x0073, 0x0070, 0x006c, 0x0061, 0x0079, 531 0x0020, 0x0055, 0x006e, 0x0069, 0x0063, 0x006f, 0x0064, 0x0065, 532 0x0020, 0x0074, 0x0065, 0x0078, 0x0074, 0x0020, 0x0077, 0x0072, 533 0x0069, 0x0074, 0x0074, 0x0065, 0x006e, 0x0020, 0x0069, 0x006e, 534 0x0020, 0x006c, 0x0061, 0x006e, 0x0067, 0x0075, 0x0061, 0x0067, 535 0x0065, 0x0073, 0x0020, 0x0077, 0x0069, 0x0074, 0x0068, 0x0020, 536 0x0063, 0x006f, 0x006d, 0x0070, 0x006c, 0x0065, 0x0078, 0x0020, 537 0x0077, 0x0072, 0x0069, 0x0074, 0x0069, 0x006e, 0x0067, 0x0020, 538 0x0073, 0x0079, 0x0073, 0x0074, 0x0065, 0x006d, 0x0073, 0x0020, 539 0x0073, 0x0075, 0x0063, 0x0068, 0x0020, 0x0061, 0x0073, 0x0020, 540 0x0048, 0x0069, 0x006e, 0x0064, 0x0069, 0x0020, 0x0028, 0x0939, 541 0x093f, 0x0928, 0x094d, 0x0926, 0x0940, 0x0029, 0x0020, 0x0054, 542 0x0068, 0x0061, 0x0069, 0x0020, 0x0028, 0x0e44, 0x0e17, 0x0e22, 543 0x0029, 0x0020, 0x0061, 0x006e, 0x0064, 0x0020, 0x0041, 0x0072, 544 0x0061, 0x0062, 0x0069, 0x0063, 0x0020, 0x0028, 0x0627, 0x0644, 545 0x0639, 0x0631, 0x0628, 0x064a, 0x0629, 0x0029, 0x002e, 0x0020, 546 0x0048, 0x0065, 0x0072, 0x0065, 0x0027, 0x0073, 0x0020, 0x0061, 547 0x0020, 0x0073, 0x0061, 0x006d, 0x0070, 0x006c, 0x0065, 0x0020, 548 0x006f, 0x0066, 0x0020, 0x0073, 0x006f, 0x006d, 0x0065, 0x0020, 549 0x0074, 0x0065, 0x0078, 0x0074, 0x0020, 0x0077, 0x0072, 0x0069, 550 0x0074, 0x0074, 0x0065, 0x006e, 0x0020, 0x0069, 0x006e, 0x0020, 551 0x0053, 0x0061, 0x006e, 0x0073, 0x006b, 0x0072, 0x0069, 0x0074, 552 0x003a, 0x0020, 0x0936, 0x094d, 0x0930, 0x0940, 0x092e, 0x0926, 553 0x094d, 0x0020, 0x092d, 0x0917, 0x0935, 0x0926, 0x094d, 0x0917, 554 0x0940, 0x0924, 0x093e, 0x0020, 0x0905, 0x0927, 0x094d, 0x092f, 555 0x093e, 0x092f, 0x0020, 0x0905, 0x0930, 0x094d, 0x091c, 0x0941, 556 0x0928, 0x0020, 0x0935, 0x093f, 0x0937, 0x093e, 0x0926, 0x0020, 557 0x092f, 0x094b, 0x0917, 0x0020, 0x0927, 0x0943, 0x0924, 0x0930, 558 0x093e, 0x0937, 0x094d, 0x091f, 0x094d, 0x0930, 0x0020, 0x0909, 559 0x0935, 0x093e, 0x091a, 0x0964, 0x0020, 0x0927, 0x0930, 0x094d, 560 0x092e, 0x0915, 0x094d, 0x0937, 0x0947, 0x0924, 0x094d, 0x0930, 561 0x0947, 0x0020, 0x0915, 0x0941, 0x0930, 0x0941, 0x0915, 0x094d, 562 0x0937, 0x0947, 0x0924, 0x094d, 0x0930, 0x0947, 0x0020, 0x0938, 563 0x092e, 0x0935, 0x0947, 0x0924, 0x093e, 0x0020, 0x092f, 0x0941, 564 0x092f, 0x0941, 0x0924, 0x094d, 0x0938, 0x0935, 0x0903, 0x0020, 565 0x092e, 0x093e, 0x092e, 0x0915, 0x093e, 0x0903, 0x0020, 0x092a, 566 0x093e, 0x0923, 0x094d, 0x0921, 0x0935, 0x093e, 0x0936, 0x094d, 567 0x091a, 0x0948, 0x0935, 0x0020, 0x0915, 0x093f, 0x092e, 0x0915, 568 0x0941, 0x0930, 0x094d, 0x0935, 0x0924, 0x0020, 0x0938, 0x0902, 569 0x091c, 0x092f, 0x0020, 0x0048, 0x0065, 0x0072, 0x0065, 0x0027, 570 0x0073, 0x0020, 0x0061, 0x0020, 0x0073, 0x0061, 0x006d, 0x0070, 571 0x006c, 0x0065, 0x0020, 0x006f, 0x0066, 0x0020, 0x0073, 0x006f, 572 0x006d, 0x0065, 0x0020, 0x0074, 0x0065, 0x0078, 0x0074, 0x0020, 573 0x0077, 0x0072, 0x0069, 0x0074, 0x0074, 0x0065, 0x006e, 0x0020, 574 0x0069, 0x006e, 0x0020, 0x0041, 0x0072, 0x0061, 0x0062, 0x0069, 575 0x0063, 0x003a, 0x0020, 0x0623, 0x0633, 0x0627, 0x0633, 0x064b, 576 0x0627, 0x060c, 0x0020, 0x062a, 0x062a, 0x0639, 0x0627, 0x0645, 577 0x0644, 0x0020, 0x0627, 0x0644, 0x062d, 0x0648, 0x0627, 0x0633, 578 0x064a, 0x0628, 0x0020, 0x0641, 0x0642, 0x0637, 0x0020, 0x0645, 579 0x0639, 0x0020, 0x0627, 0x0644, 0x0623, 0x0631, 0x0642, 0x0627, 580 0x0645, 0x060c, 0x0020, 0x0648, 0x062a, 0x0642, 0x0648, 0x0645, 581 0x0020, 0x0628, 0x062a, 0x062e, 0x0632, 0x064a, 0x0646, 0x0020, 582 0x0627, 0x0644, 0x0623, 0x062d, 0x0631, 0x0641, 0x0020, 0x0648, 583 0x0627, 0x0644, 0x0645, 0x062d, 0x0627, 0x0631, 0x0641, 0x0020, 584 0x0627, 0x0644, 0x0623, 0x062e, 0x0631, 0x0649, 0x0020, 0x0628, 585 0x0639, 0x062f, 0x0020, 0x0623, 0x0646, 0x0020, 0x062a, 0x064f, 586 0x0639, 0x0637, 0x064a, 0x0020, 0x0631, 0x0642, 0x0645, 0x0627, 587 0x0020, 0x0645, 0x0639, 0x064a, 0x0646, 0x0627, 0x0020, 0x0644, 588 0x0643, 0x0644, 0x0020, 0x0648, 0x0627, 0x062d, 0x062f, 0x0020, 589 0x0645, 0x0646, 0x0647, 0x0627, 0x002e, 0x0020, 0x0648, 0x0642, 590 0x0628, 0x0644, 0x0020, 0x0627, 0x062e, 0x062a, 0x0631, 0x0627, 591 0x0639, 0x0020, 0x0022, 0x064a, 0x0648, 0x0646, 0x0650, 0x0643, 592 0x0648, 0x062f, 0x0022, 0x060c, 0x0020, 0x0643, 0x0627, 0x0646, 593 0x0020, 0x0647, 0x0646, 0x0627, 0x0643, 0x0020, 0x0645, 0x0626, 594 0x0627, 0x062a, 0x0020, 0x0627, 0x0644, 0x0623, 0x0646, 0x0638, 595 0x0645, 0x0629, 0x0020, 0x0644, 0x0644, 0x062a, 0x0634, 0x0641, 596 0x064a, 0x0631, 0x0020, 0x0648, 0x062a, 0x062e, 0x0635, 0x064a, 597 0x0635, 0x0020, 0x0647, 0x0630, 0x0647, 0x0020, 0x0627, 0x0644, 598 0x0623, 0x0631, 0x0642, 0x0627, 0x0645, 0x0020, 0x0644, 0x0644, 599 0x0645, 0x062d, 0x0627, 0x0631, 0x0641, 0x060c, 0x0020, 0x0648, 600 0x0644, 0x0645, 0x0020, 0x064a, 0x0648, 0x062c, 0x062f, 0x0020, 601 0x0646, 0x0638, 0x0627, 0x0645, 0x0020, 0x062a, 0x0634, 0x0641, 602 0x064a, 0x0631, 0x0020, 0x0648, 0x0627, 0x062d, 0x062f, 0x0020, 603 0x064a, 0x062d, 0x062a, 0x0648, 0x064a, 0x0020, 0x0639, 0x0644, 604 0x0649, 0x0020, 0x062c, 0x0645, 0x064a, 0x0639, 0x0020, 0x0627, 605 0x0644, 0x0645, 0x062d, 0x0627, 0x0631, 0x0641, 0x0020, 0x0627, 606 0x0644, 0x0636, 0x0631, 0x0648, 0x0631, 0x064a, 0x0629, 0x0020, 607 0x0061, 0x006e, 0x0064, 0x0020, 0x0068, 0x0065, 0x0072, 0x0065, 608 0x0027, 0x0073, 0x0020, 0x0061, 0x0020, 0x0073, 0x0061, 0x006d, 609 0x0070, 0x006c, 0x0065, 0x0020, 0x006f, 0x0066, 0x0020, 0x0073, 610 0x006f, 0x006d, 0x0065, 0x0020, 0x0074, 0x0065, 0x0078, 0x0074, 611 0x0020, 0x0077, 0x0072, 0x0069, 0x0074, 0x0074, 0x0065, 0x006e, 612 0x0020, 0x0069, 0x006e, 0x0020, 0x0054, 0x0068, 0x0061, 0x0069, 613 0x003a, 0x0020, 0x0e1a, 0x0e17, 0x0e17, 0x0e35, 0x0e48, 0x0e51, 614 0x0e1e, 0x0e32, 0x0e22, 0x0e38, 0x0e44, 0x0e0b, 0x0e42, 0x0e04, 615 0x0e25, 0x0e19, 0x0e42, 0x0e14, 0x0e42, 0x0e23, 0x0e18, 0x0e35, 616 0x0e2d, 0x0e32, 0x0e28, 0x0e31, 0x0e22, 0x0e2d, 0x0e22, 0x0e39, 617 0x0e48, 0x0e17, 0x0e48, 0x0e32, 0x0e21, 0x0e01, 0x0e25, 0x0e32, 618 0x0e07, 0x0e17, 0x0e38, 0x0e48, 0x0e07, 0x0e43, 0x0e2b, 0x0e0d, 619 0x0e48, 0x0e43, 0x0e19, 0x0e41, 0x0e04, 0x0e19, 0x0e0b, 0x0e31, 620 0x0e2a, 0x0e01, 0x0e31, 0x0e1a, 0x0e25, 0x0e38, 0x0e07, 0x0e40, 621 0x0e2e, 0x0e19, 0x0e23, 0x0e35, 0x0e0a, 0x0e32, 0x0e27, 0x0e44, 622 0x0e23, 0x0e48, 0x0e41, 0x0e25, 0x0e30, 0x0e1b, 0x0e49, 0x0e32, 623 0x0e40, 0x0e2d, 0x0e47, 0x0e21, 0x0e20, 0x0e23, 0x0e23, 0x0e22, 624 0x0e32, 0x0e0a, 0x0e32, 0x0e27, 0x0e44, 0x0e23, 0x0e48, 0x0e1a, 625 0x0e49, 0x0e32, 0x0e19, 0x0e02, 0x0e2d, 0x0e07, 0x0e1e, 0x0e27, 626 0x0e01, 0x0e40, 0x0e02, 0x0e32, 0x0e2b, 0x0e25, 0x0e31, 0x0e07, 627 0x0e40, 0x0e25, 0x0e47, 0x0e01, 0x0e40, 0x0e1e, 0x0e23, 0x0e32, 628 0x0e30, 0x0e44, 0x0e21, 0x0e49, 0x0e2a, 0x0e23, 0x0e49, 0x0e32, 629 0x0e07, 0x0e1a, 0x0e49, 0x0e32, 0x0e19, 0x0e15, 0x0e49, 0x0e2d, 630 0x0e07, 0x0e02, 0x0e19, 0x0e21, 0x0e32, 0x0e14, 0x0e49, 0x0e27, 631 0x0e22, 0x0e40, 0x0e01, 0x0e27, 0x0e35, 0x0e22, 0x0e19, 0x0e40, 632 0x0e1b, 0x0e47, 0x0e19, 0x0e23, 0x0e30, 0x0e22, 0x0e30, 0x0e17, 633 0x0e32, 0x0e07, 0x0e2b, 0x0e25, 0x0e32, 0x0e22, 0x0e44, 0x0e21, 634 0x0e25, 0x0e4c 635 }; 636 le_int32 charCount = LE_ARRAY_SIZE(chars); 637 le_int32 charIndex = 0, lineNumber = 1; 638 le_int32 run, i; 639 const float lineWidth = 600; 640 641 font = le_simpleFontOpen(12, &status); 642 643 if (LE_FAILURE(status)) { 644 log_err("le_simpleFontOpen(12, &status) failed"); 645 goto finish; 646 } 647 648 fontRuns = pl_openEmptyFontRuns(0); 649 pl_addFontRun(fontRuns, font, charCount); 650 651 paragraph = pl_create(chars, charCount, fontRuns, NULL, NULL, NULL, 0, FALSE, &status); 652 653 pl_closeFontRuns(fontRuns); 654 655 if (LE_FAILURE(status)) { 656 log_err("pl_create failed."); 657 goto close_font; 658 } 659 660 pl_reflow(paragraph); 661 while ((line = pl_nextLine(paragraph, lineWidth)) != NULL) { 662 le_int32 runCount = pl_countLineRuns(line); 663 664 for(run = 0; run < runCount; run += 1) { 665 const pl_visualRun *visualRun = pl_getLineVisualRun(line, run); 666 const le_int32 glyphCount = pl_getVisualRunGlyphCount(visualRun); 667 const le_int32 *glyphToCharMap = pl_getVisualRunGlyphToCharMap(visualRun); 668 669 if (pl_getVisualRunDirection(visualRun) == UBIDI_RTL) { 670 /* 671 * For a right to left run, make sure that the character indices 672 * increase from the right most glyph to the left most glyph. If 673 * there are any one to many glyph substitutions, we might get several 674 * glyphs in a row with the same character index. 675 */ 676 for(i = glyphCount - 1; i >= 0; i -= 1) { 677 le_int32 ix = glyphToCharMap[i]; 678 679 if (ix != charIndex) { 680 if (ix != charIndex - 1) { 681 log_err("Bad glyph to char index for glyph %d on line %d: expected %d, got %d\n", 682 i, lineNumber, charIndex, ix); 683 goto close_paragraph; /* once there's one error, we can't count on anything else... */ 684 } 685 } else { 686 charIndex += 1; 687 } 688 } 689 } else { 690 /* 691 * We can't just check the order of the character indices 692 * for left to right runs because Indic text might have been 693 * reordered. What we can do is find the minimum and maximum 694 * character indices in the run and make sure that the minimum 695 * is equal to charIndex and then advance charIndex to the maximum. 696 */ 697 le_int32 minIndex = 0x7FFFFFFF, maxIndex = -1; 698 699 for(i = 0; i < glyphCount; i += 1) { 700 le_int32 ix = glyphToCharMap[i]; 701 702 if (ix > maxIndex) { 703 maxIndex = ix; 704 } 705 706 if (ix < minIndex) { 707 minIndex = ix; 708 } 709 } 710 711 if (minIndex != charIndex) { 712 log_err("Bad minIndex for run %d on line %d: expected %d, got %d\n", 713 run, lineNumber, charIndex, minIndex); 714 goto close_paragraph; /* once there's one error, we can't count on anything else... */ 715 } 716 717 charIndex = maxIndex + 1; 718 } 719 } 720 721 lineNumber += 1; 722 } 723 724 close_paragraph: 725 pl_close(paragraph); 726 727 close_font: 728 le_fontClose(font); 729 730 finish: 731 return; 732 #endif 733 } 734 735 U_CFUNC void addCTests(TestNode **root) 736 { 737 addTest(root, &ParamTest, "c_api/ParameterTest"); 738 addTest(root, &FactoryTest, "c_api/FactoryTest"); 739 addTest(root, &AccessTest, "c_layout/AccessTest"); 740 addTest(root, &DataDrivenTest, "c_layout/DataDrivenTest"); 741 addTest(root, &GlyphToCharTest, "c_paragraph/GlyphToCharTest"); 742 } 743 744 745
