Lines Matching defs:bd
28 Bidi bd;
50 bd = new Bidi(null, Bidi.DIRECTION_RIGHT_TO_LEFT);
57 bd = new Bidi(null, 0, new byte[] { 0 }, 0, 0,
65 bd = new Bidi(null);
70 bd = new Bidi("a".toCharArray(), 0, null, 0, 1,
76 bd = new Bidi("1".toCharArray(), 0, new byte[] { 0 }, 0, 20,
84 bd = new Bidi("1234567".toCharArray(), 0, new byte[] { 0 }, 0, 4,
92 bd = new Bidi("1234567".toCharArray(), 4, new byte[] { 0, 1, 2, 3,
100 bd = new Bidi("1234567".toCharArray(), 0, new byte[] { 0, 1, 2, 3,
109 bd = new Bidi(new char[] { 't','t','t'}, -1, new byte[] { 2, 2 }, 1, 1, 1);
116 bd = new Bidi(new char[] { 't','t','t'}, 1, new byte[] { 2, 2 }, -1, 1, 1);
123 bd = new Bidi(new char[] { 't','t','t'}, 1, new byte[] { 2, 2 }, 1, -1, 1);
130 bd = new Bidi(new char[] {}, 5, new byte[] { 2, 2, 2, 2, 2, 2 }, 8, Integer.MAX_VALUE, 5);
137 bd = new Bidi(null, 5, null, 8, Integer.MAX_VALUE, 5);
143 bd = new Bidi(new char[] {'o'}, 0, new byte[] { 2, 2}, 2, 0, 2 );
147 bd = new Bidi("", Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
148 assertTrue(bd.baseIsLeftToRight());
149 assertEquals(0, bd.getBaseLevel());
150 assertEquals(0, bd.getLength());
151 assertEquals(0, bd.getLevelAt(0));
152 assertEquals(0, bd.getLevelAt(1000));
153 assertEquals(1, bd.getRunCount());
154 assertRunArrayEquals(new int[][] { { 0, 0, 0 } }, bd);
155 assertTrue(bd.isLeftToRight());
156 assertFalse(bd.isMixed());
157 assertFalse(bd.isRightToLeft());
159 bd = new Bidi("", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
160 assertFalse(bd.baseIsLeftToRight());
161 assertEquals(1, bd.getBaseLevel());
162 assertEquals(0, bd.getLength());
163 assertEquals(1, bd.getLevelAt(0));
164 assertEquals(1, bd.getLevelAt(1000));
165 assertEquals(1, bd.getRunCount());
166 assertRunArrayEquals(new int[][] { { 0, 0, 1 }, }, bd);
167 assertFalse(bd.isLeftToRight());
168 assertFalse(bd.isMixed());
169 assertTrue(bd.isRightToLeft());
171 bd = new Bidi("", Bidi.DIRECTION_LEFT_TO_RIGHT);
172 assertTrue(bd.baseIsLeftToRight());
173 assertEquals(0, bd.getBaseLevel());
174 assertEquals(0, bd.getLength());
175 assertEquals(0, bd.getLevelAt(0));
176 assertEquals(0, bd.getLevelAt(1000));
177 assertEquals(1, bd.getRunCount());
178 assertRunArrayEquals(new int[][] { { 0, 0, 0 }, }, bd);
179 assertTrue(bd.isLeftToRight());
180 assertFalse(bd.isMixed());
181 assertFalse(bd.isRightToLeft());
183 bd = new Bidi("", Bidi.DIRECTION_RIGHT_TO_LEFT);
184 assertFalse(bd.baseIsLeftToRight());
185 assertEquals(1, bd.getBaseLevel());
186 assertEquals(0, bd.getLength());
187 assertEquals(1, bd.getLevelAt(0));
188 assertEquals(1, bd.getLevelAt(1000));
189 assertEquals(1, bd.getRunCount());
190 assertRunArrayEquals(new int[][] { { 0, 0, 1 }, }, bd);
191 assertFalse(bd.isLeftToRight());
192 assertFalse(bd.isMixed());
193 assertTrue(bd.isRightToLeft());
197 bd = new Bidi(" ", Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
198 assertTrue(bd.baseIsLeftToRight());
199 assertEquals(0, bd.getBaseLevel());
200 assertEquals(1, bd.getLength());
201 assertEquals(0, bd.getLevelAt(0));
202 assertEquals(0, bd.getLevelAt(1000));
203 assertEquals(1, bd.getRunCount());
204 assertRunArrayEquals(new int[][] { { 0, 1, 0 }, }, bd);
205 assertTrue(bd.isLeftToRight());
206 assertFalse(bd.isMixed());
207 assertFalse(bd.isRightToLeft());
209 bd = new Bidi(" ", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
210 assertFalse(bd.baseIsLeftToRight());
211 assertEquals(1, bd.getBaseLevel());
212 assertEquals(1, bd.getLength());
213 assertEquals(1, bd.getLevelAt(0));
214 assertEquals(1, bd.getLevelAt(1000));
215 assertEquals(1, bd.getRunCount());
216 assertRunArrayEquals(new int[][] { { 0, 1, 1 }, }, bd);
217 assertFalse(bd.isLeftToRight());
218 assertFalse(bd.isMixed());
219 assertTrue(bd.isRightToLeft());
221 bd = new Bidi(" ", Bidi.DIRECTION_LEFT_TO_RIGHT);
222 assertTrue(bd.baseIsLeftToRight());
223 assertEquals(0, bd.getBaseLevel());
224 assertEquals(1, bd.getLength());
225 assertEquals(0, bd.getLevelAt(0));
226 assertEquals(0, bd.getLevelAt(1000));
227 assertEquals(1, bd.getRunCount());
228 assertRunArrayEquals(new int[][] { { 0, 1, 0 }, }, bd);
229 assertTrue(bd.isLeftToRight());
230 assertFalse(bd.isMixed());
231 assertFalse(bd.isRightToLeft());
233 bd = new Bidi(" ", Bidi.DIRECTION_RIGHT_TO_LEFT);
234 assertFalse(bd.baseIsLeftToRight());
235 assertEquals(1, bd.getBaseLevel());
236 assertEquals(1, bd.getLength());
237 assertEquals(1, bd.getLevelAt(0));
238 assertEquals(1, bd.getLevelAt(1000));
239 assertEquals(1, bd.getRunCount());
240 assertRunArrayEquals(new int[][] { { 0, 1, 1 }, }, bd);
241 assertFalse(bd.isLeftToRight());
242 assertFalse(bd.isMixed());
243 assertTrue(bd.isRightToLeft());
247 bd = new Bidi("t", Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
248 assertTrue(bd.baseIsLeftToRight());
249 assertEquals(0, bd.getBaseLevel());
250 assertEquals(1, bd.getLength());
251 assertEquals(0, bd.getLevelAt(0));
252 assertEquals(0, bd.getLevelAt(1000));
253 assertEquals(1, bd.getRunCount());
254 assertRunArrayEquals(new int[][] { { 0, 1, 0 }, }, bd);
255 assertTrue(bd.isLeftToRight());
256 assertFalse(bd.isMixed());
257 assertFalse(bd.isRightToLeft());
259 bd = new Bidi("t", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
260 assertTrue(bd.baseIsLeftToRight());
261 assertEquals(0, bd.getBaseLevel());
262 assertEquals(1, bd.getLength());
263 assertEquals(0, bd.getLevelAt(0));
264 assertEquals(0, bd.getLevelAt(1000));
265 assertEquals(1, bd.getRunCount());
266 assertRunArrayEquals(new int[][] { { 0, 1, 0 }, }, bd);
267 assertTrue(bd.isLeftToRight());
268 assertFalse(bd.isMixed());
269 assertFalse(bd.isRightToLeft());
271 bd = new Bidi("t", Bidi.DIRECTION_LEFT_TO_RIGHT);
272 assertTrue(bd.baseIsLeftToRight());
273 assertEquals(0, bd.getBaseLevel());
274 assertEquals(1, bd.getLength());
275 assertEquals(0, bd.getLevelAt(0));
276 assertEquals(0, bd.getLevelAt(1000));
277 assertEquals(1, bd.getRunCount());
278 assertRunArrayEquals(new int[][] { { 0, 1, 0 }, }, bd);
279 assertTrue(bd.isLeftToRight());
280 assertFalse(bd.isMixed());
281 assertFalse(bd.isRightToLeft());
285 bd = new Bidi("", 173);
286 assertTrue(bd.baseIsLeftToRight());
287 assertEquals(0, bd.getBaseLevel());
288 assertEquals(0, bd.getLength());
289 assertEquals(0, bd.getLevelAt(0));
290 assertEquals(0, bd.getLevelAt(1000));
291 assertEquals(1, bd.getRunCount());
292 assertRunArrayEquals(new int[][] { { 0, 0, 0 }, }, bd);
293 assertTrue(bd.isLeftToRight());
294 assertFalse(bd.isMixed());
295 assertFalse(bd.isRightToLeft());
300 bd = new Bidi("".toCharArray(), 0, new byte[] {}, 0, 1,
309 bd = new Bidi(new char[] { 's', 's', 's' }, 0, new byte[] { (byte) -7,
312 assertTrue(bd.baseIsLeftToRight());
313 assertEquals(0, bd.getBaseLevel());
314 assertEquals(3, bd.getLength());
315 assertEquals(7, bd.getLevelAt(0));
316 assertEquals(2, bd.getLevelAt(1));
317 assertEquals(3, bd.getLevelAt(2));
318 assertEquals(0, bd.getLevelAt(1000));
319 assertEquals(3, bd.getRunCount());
321 { 2, 3, 3 }, }, bd);
322 assertFalse(bd.isLeftToRight());
323 assertTrue(bd.isMixed());
324 assertFalse(bd.isRightToLeft());
326 bd = new Bidi(new char[] { 's', 's', 's' }, 0, new byte[] { (byte) -1,
329 assertTrue(bd.baseIsLeftToRight());
330 assertEquals(0, bd.getBaseLevel());
331 assertEquals(3, bd.getLength());
332 assertEquals(1, bd.getLevelAt(0));
333 assertEquals(2, bd.getLevelAt(1));
334 assertEquals(3, bd.getLevelAt(2));
335 assertEquals(0, bd.getLevelAt(1000));
336 assertEquals(3, bd.getRunCount());
338 { 2, 3, 3 }, }, bd);
339 assertFalse(bd.isLeftToRight());
340 assertTrue(bd.isMixed());
341 assertFalse(bd.isRightToLeft());
343 bd = new Bidi(new char[] { 's', 's', 's' }, 0, new byte[] { (byte) -1,
345 assertTrue(bd.baseIsLeftToRight());
346 assertEquals(0, bd.getBaseLevel());
347 assertEquals(3, bd.getLength());
348 assertEquals(1, bd.getLevelAt(0));
349 assertEquals(2, bd.getLevelAt(1));
350 assertEquals(3, bd.getLevelAt(2));
351 assertEquals(0, bd.getLevelAt(1000));
352 assertEquals(3, bd.getRunCount());
354 { 2, 3, 3 }, }, bd);
355 assertFalse(bd.isLeftToRight());
356 assertTrue(bd.isMixed());
357 assertFalse(bd.isRightToLeft());
359 bd = new Bidi(new char[] { 's', 's', 's' }, 0, new byte[] { (byte) -1,
361 assertFalse(bd.baseIsLeftToRight());
362 assertEquals(1, bd.getBaseLevel());
363 assertEquals(3, bd.getLength());
364 assertEquals(1, bd.getLevelAt(0));
365 assertEquals(2, bd.getLevelAt(1));
366 assertEquals(3, bd.getLevelAt(2));
367 assertEquals(1, bd.getLevelAt(1000));
368 assertEquals(3, bd.getRunCount());
370 { 2, 3, 3 }, }, bd);
371 assertFalse(bd.isLeftToRight());
372 assertTrue(bd.isMixed());
373 assertFalse(bd.isRightToLeft());
377 bd = new Bidi(new char[] { 's', 's', 's' }, 0, new byte[] { (byte) 0,
379 assertFalse(bd.baseIsLeftToRight());
380 assertEquals(1, bd.getBaseLevel());
381 assertEquals(3, bd.getLength());
382 assertEquals(2, bd.getLevelAt(0));
383 assertEquals(2, bd.getLevelAt(1));
384 assertEquals(2, bd.getLevelAt(2));
385 assertEquals(1, bd.getLevelAt(1000));
386 assertEquals(1, bd.getRunCount());
387 assertRunArrayEquals(new int[][] { { 0, 3, 2 }, }, bd);
388 assertFalse(bd.isLeftToRight());
389 assertTrue(bd.isMixed());
390 assertFalse(bd.isRightToLeft());
394 bd = new Bidi(new char[] { 's', 's', 's' }, 0, new byte[] { (byte) 1,
396 assertFalse(bd.baseIsLeftToRight());
397 assertEquals(1, bd.getBaseLevel());
398 assertEquals(3, bd.getLength());
399 assertEquals(2, bd.getLevelAt(0));
400 assertEquals(2, bd.getLevelAt(1));
401 assertEquals(4, bd.getLevelAt(2));
402 assertEquals(1, bd.getLevelAt(1000));
403 assertEquals(2, bd.getRunCount());
404 assertRunArrayEquals(new int[][] { { 0, 2, 2 }, { 2, 3, 4 }, }, bd);
405 assertFalse(bd.isLeftToRight());
406 assertTrue(bd.isMixed());
407 assertFalse(bd.isRightToLeft());
411 bd = new Bidi("\u05D0", Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
412 assertFalse(bd.baseIsLeftToRight());
413 assertEquals(1, bd.getBaseLevel());
414 assertEquals(1, bd.getLength());
415 assertEquals(1, bd.getLevelAt(0));
416 assertEquals(1, bd.getLevelAt(1000));
417 assertEquals(1, bd.getRunCount());
418 assertRunArrayEquals(new int[][] { { 0, 1, 1 }, }, bd);
419 assertFalse(bd.isLeftToRight());
420 assertFalse(bd.isMixed());
421 assertTrue(bd.isRightToLeft());
423 bd = new Bidi("\u05D0", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
424 assertFalse(bd.baseIsLeftToRight());
425 assertEquals(1, bd.getBaseLevel());
426 assertEquals(1, bd.getLength());
427 assertEquals(1, bd.getLevelAt(0));
428 assertEquals(1, bd.getLevelAt(1000));
429 assertEquals(1, bd.getRunCount());
430 assertRunArrayEquals(new int[][] { { 0, 1, 1 }, }, bd);
431 assertFalse(bd.isLeftToRight());
432 assertFalse(bd.isMixed());
433 assertTrue(bd.isRightToLeft());
435 bd = new Bidi("\u05D0", Bidi.DIRECTION_RIGHT_TO_LEFT);
436 assertFalse(bd.baseIsLeftToRight());
437 assertEquals(1, bd.getBaseLevel());
438 assertEquals(1, bd.getLength());
439 assertEquals(1, bd.getLevelAt(0));
440 assertEquals(1, bd.getLevelAt(1000));
441 assertEquals(1, bd.getRunCount());
442 assertRunArrayEquals(new int[][] { { 0, 1, 1 }, }, bd);
443 assertFalse(bd.isLeftToRight());
444 assertFalse(bd.isMixed());
445 assertTrue(bd.isRightToLeft());
449 bd = new Bidi("\u05D0a", Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
450 assertFalse(bd.baseIsLeftToRight());
451 assertEquals(1, bd.getBaseLevel());
452 assertEquals(2, bd.getLength());
453 assertEquals(1, bd.getLevelAt(0));
454 assertEquals(2, bd.getLevelAt(1));
455 assertEquals(1, bd.getLevelAt(1000));
456 assertEquals(2, bd.getRunCount());
457 assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 }, }, bd);
458 assertFalse(bd.isLeftToRight());
459 assertTrue(bd.isMixed());
460 assertFalse(bd.isRightToLeft());
462 bd = new Bidi("\u05D0a", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
463 assertFalse(bd.baseIsLeftToRight());
464 assertEquals(1, bd.getBaseLevel());
465 assertEquals(2, bd.getLength());
466 assertEquals(1, bd.getLevelAt(0));
467 assertEquals(2, bd.getLevelAt(1));
468 assertEquals(1, bd.getLevelAt(1000));
469 assertEquals(2, bd.getRunCount());
470 assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 }, }, bd);
471 assertFalse(bd.isLeftToRight());
472 assertTrue(bd.isMixed());
473 assertFalse(bd.isRightToLeft());
475 bd = new Bidi("\u05D0a", Bidi.DIRECTION_LEFT_TO_RIGHT);
476 assertTrue(bd.baseIsLeftToRight());
477 assertEquals(0, bd.getBaseLevel());
478 assertEquals(2, bd.getLength());
479 assertEquals(1, bd.getLevelAt(0));
480 assertEquals(0, bd.getLevelAt(1));
481 assertEquals(0, bd.getLevelAt(1000));
482 assertEquals(2, bd.getRunCount());
483 bd);
484 assertFalse(bd.isLeftToRight());
485 assertTrue(bd.isMixed());
486 assertFalse(bd.isRightToLeft());
488 bd = new Bidi("\u05D0a", Bidi.DIRECTION_RIGHT_TO_LEFT);
489 assertFalse(bd.baseIsLeftToRight());
490 assertEquals(1, bd.getBaseLevel());
491 assertEquals(2, bd.getLength());
492 assertEquals(1, bd.getLevelAt(0));
493 assertEquals(2, bd.getLevelAt(1));
494 assertEquals(1, bd.getLevelAt(1000));
495 assertEquals(2, bd.getRunCount());
496 assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 }, }, bd);
497 assertFalse(bd.isLeftToRight());
498 assertTrue(bd.isMixed());
499 assertFalse(bd.isRightToLeft());
503 bd = new Bidi("a\u05D0", Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
504 assertTrue(bd.baseIsLeftToRight());
505 assertEquals(0, bd.getBaseLevel());
506 assertEquals(2, bd.getLength());
507 assertEquals(0, bd.getLevelAt(0));
508 assertEquals(1, bd.getLevelAt(1));
509 assertEquals(0, bd.getLevelAt(1000));
510 assertEquals(2, bd.getRunCount());
511 assertRunArrayEquals(new int[][] { { 0, 1, 0 }, { 1, 2, 1 }, }, bd);
512 assertFalse(bd.isLeftToRight());
513 assertTrue(bd.isMixed());
514 assertFalse(bd.isRightToLeft());
516 bd = new Bidi("a\u05D0", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
517 assertTrue(bd.baseIsLeftToRight());
518 assertEquals(0, bd.getBaseLevel());
519 assertEquals(2, bd.getLength());
520 assertEquals(0, bd.getLevelAt(0));
521 assertEquals(1, bd.getLevelAt(1));
522 assertEquals(0, bd.getLevelAt(1000));
523 assertEquals(2, bd.getRunCount());
524 assertRunArrayEquals(new int[][] { { 0, 1, 0 }, { 1, 2, 1 }, }, bd);
525 assertFalse(bd.isLeftToRight());
526 assertTrue(bd.isMixed());
527 assertFalse(bd.isRightToLeft());
529 bd = new Bidi("a\u05D0", Bidi.DIRECTION_LEFT_TO_RIGHT);
530 assertTrue(bd.baseIsLeftToRight());
531 assertEquals(0, bd.getBaseLevel());
532 assertEquals(2, bd.getLength());
533 assertEquals(0, bd.getLevelAt(0));
534 assertEquals(1, bd.getLevelAt(1));
535 assertEquals(0, bd.getLevelAt(1000));
536 assertEquals(2, bd.getRunCount());
537 assertRunArrayEquals(new int[][] { { 0, 1, 0 }, { 1, 2, 1 }, }, bd);
538 assertFalse(bd.isLeftToRight());
539 assertTrue(bd.isMixed());
540 assertFalse(bd.isRightToLeft());
542 bd = new Bidi("a\u05D0", Bidi.DIRECTION_RIGHT_TO_LEFT);
543 assertFalse(bd.baseIsLeftToRight());
544 assertEquals(1, bd.getBaseLevel());
545 assertEquals(2, bd.getLength());
546 assertEquals(2, bd.getLevelAt(0));
547 assertEquals(1, bd.getLevelAt(1));
548 assertEquals(1, bd.getLevelAt(1000));
549 assertEquals(2, bd.getRunCount());
550 assertRunArrayEquals(new int[][] { { 0, 1, 2 }, { 1, 2, 1 }, }, bd);
551 assertFalse(bd.isLeftToRight());
552 assertTrue(bd.isMixed());
553 assertFalse(bd.isRightToLeft());
562 bd = new Bidi("t", Bidi.DIRECTION_RIGHT_TO_LEFT);
563 assertFalse(bd.baseIsLeftToRight());
565 assertEquals(1, bd.getBaseLevel());
566 assertEquals(1, bd.getLength());
567 assertEquals(2, bd.getLevelAt(0));
568 assertEquals(1, bd.getLevelAt(1000));
569 assertEquals(1, bd.getRunCount());
570 assertRunArrayEquals(new int[][] { { 0, 1, 2 }, }, bd);
571 assertFalse(bd.isLeftToRight());
572 assertTrue(bd.isMixed());
573 assertFalse(bd.isRightToLeft());
578 bd = new Bidi("\u05D0", Bidi.DIRECTION_LEFT_TO_RIGHT);
579 assertTrue(bd.baseIsLeftToRight());
580 assertEquals(0, bd.getBaseLevel());
581 assertEquals(1, bd.getLength());
582 assertEquals(1, bd.getLevelAt(0));
583 assertEquals(0, bd.getLevelAt(1000));
584 assertEquals(1, bd.getRunCount());
585 assertRunArrayEquals(new int[][] { { 0, 1, 1 }, }, bd);
586 assertFalse(bd.isLeftToRight());
587 assertTrue(bd.isMixed());
588 assertFalse(bd.isRightToLeft());
592 bd = new Bidi("a\u05D0a\"a\u05D0\"\u05D0a",
594 assertFalse(bd.baseIsLeftToRight());
595 assertEquals(1, bd.getBaseLevel());
596 assertEquals(9, bd.getLength());
597 assertEquals(2, bd.getLevelAt(0));
598 assertEquals(1, bd.getLevelAt(1));
599 assertEquals(2, bd.getLevelAt(2));
600 assertEquals(2, bd.getLevelAt(3));
601 assertEquals(2, bd.getLevelAt(4));
602 assertEquals(1, bd.getLevelAt(5));
603 assertEquals(1, bd.getLevelAt(6));
604 assertEquals(1, bd.getLevelAt(7));
605 assertEquals(2, bd.getLevelAt(8));
606 assertEquals(1, bd.getLevelAt(1000));
607 assertEquals(5, bd.getRunCount());
609 { 2, 5, 2 }, { 5, 8, 1 }, { 8, 9, 2 }, }, bd);
610 assertFalse(bd.isLeftToRight());
611 assertTrue(bd.isMixed());
612 assertFalse(bd.isRightToLeft());
616 bd = new Bidi("a\u05D0a\"a\u05D0\"\u05D0a".toCharArray(), 0,
619 assertFalse(bd.baseIsLeftToRight());
620 assertEquals(1, bd.getBaseLevel());
621 assertEquals(9, bd.getLength());
622 assertEquals(2, bd.getLevelAt(0));
623 assertEquals(1, bd.getLevelAt(1));
624 assertEquals(2, bd.getLevelAt(2));
625 assertEquals(3, bd.getLevelAt(3));
626 assertEquals(3, bd.getLevelAt(4));
627 assertEquals(3, bd.getLevelAt(5));
628 assertEquals(2, bd.getLevelAt(6));
629 assertEquals(1, bd.getLevelAt(7));
630 assertEquals(4, bd.getLevelAt(8));
631 assertEquals(1, bd.getLevelAt(1000));
632 assertEquals(7, bd.getRunCount());
635 { 8, 9, 4 }, }, bd);
636 assertFalse(bd.isLeftToRight());
637 assertTrue(bd.isMixed());
638 assertFalse(bd.isRightToLeft());
714 bd = new Bidi(new char[] { '\u05D0', '\u05D0', '\u05D0' }, 0,
717 assertFalse(bd.baseIsLeftToRight());
718 assertEquals(1, bd.getBaseLevel());
719 assertEquals(3, bd.getLength());
720 assertEquals(1, bd.getLevelAt(0));
721 assertEquals(2, bd.getLevelAt(1));
722 assertEquals(3, bd.getLevelAt(2));
723 assertEquals(1, bd.getLevelAt(1000));
724 assertEquals(3, bd.getRunCount());
726 { 2, 3, 3 }, }, bd);
727 assertFalse(bd.isLeftToRight());
728 assertTrue(bd.isMixed());
729 assertFalse(bd.isRightToLeft());
731 bd = new Bidi(new char[] { '\u05D0', '\u05D0', '\u05D0' }, 0,
734 assertFalse(bd.baseIsLeftToRight());
735 assertEquals(1, bd.getBaseLevel());
736 assertEquals(3, bd.getLength());
737 assertEquals(1, bd.getLevelAt(0));
738 assertEquals(2, bd.getLevelAt(1));
739 assertEquals(3, bd.getLevelAt(2));
740 assertEquals(1, bd.getLevelAt(1000));
741 assertEquals(3, bd.getRunCount());
743 { 2, 3, 3 }, }, bd);
744 assertFalse(bd.isLeftToRight());
745 assertTrue(bd.isMixed());
746 assertFalse(bd.isRightToLeft());
748 bd = new Bidi(new char[] { '\u05D0', '\u05D0', '\u05D0' }, 0,
751 assertTrue(bd.baseIsLeftToRight());
752 assertEquals(0, bd.getBaseLevel());
753 assertEquals(3, bd.getLength());
754 assertEquals(1, bd.getLevelAt(0));
755 assertEquals(2, bd.getLevelAt(1));
756 assertEquals(3, bd.getLevelAt(2));
757 assertEquals(0, bd.getLevelAt(1000));
758 assertEquals(3, bd.getRunCount());
760 { 2, 3, 3 }, }, bd);
761 assertFalse(bd.isLeftToRight());
762 assertTrue(bd.isMixed());
763 assertFalse(bd.isRightToLeft());
765 bd = new Bidi(new char[] { '\u05D0', '\u05D0', '\u05D0' }, 0,
768 assertFalse(bd.baseIsLeftToRight());
769 assertEquals(1, bd.getBaseLevel());
770 assertEquals(3, bd.getLength());
771 assertEquals(1, bd.getLevelAt(0));
772 assertEquals(2, bd.getLevelAt(1));
773 assertEquals(3, bd.getLevelAt(2));
774 assertEquals(1, bd.getLevelAt(1000));
775 assertEquals(3, bd.getRunCount());
777 { 2, 3, 3 }, }, bd);
778 assertFalse(bd.isLeftToRight());
779 assertTrue(bd.isMixed());
780 assertFalse(bd.isRightToLeft());
784 bd = new Bidi("a\u05D0a\u05D0a\u05D0\"\u05D0a".toCharArray(), 0,
787 Bidi line = bd.createLineBidi(2, 7);
852 bd = new Bidi("aaaaa".toCharArray(), 0,
855 Bidi line = bd.createLineBidi(1, 4);
