]> git.saurik.com Git - apple/icu.git/blame - icuSources/test/letest/cletest.c
ICU-511.25.tar.gz
[apple/icu.git] / icuSources / test / letest / cletest.c
CommitLineData
46f4442e
A
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
36U_CDECL_BEGIN
37static 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
179bail:
180 le_close(engine);
181 le_fontClose(font);
182}
183U_CDECL_END
184
185U_CDECL_BEGIN
186static 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}
206U_CDECL_END
207
208U_CDECL_BEGIN
209static 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
278bail:
279 le_close(engine);
280 le_fontClose(font);
281}
282U_CDECL_END
283
284static 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
335static 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/ */
366static 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
385static 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
394static 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
421static 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
438static 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
488free_expected:
489 le_fontClose(font);
490}
491
492static 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 */
512static 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
723close_paragraph:
724 pl_close(paragraph);
725
726close_font:
727 le_fontClose(font);
728
729finish:
730 return;
731}
732
733U_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