/*
*******************************************************************************
* Copyright (C) 2008, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
*/
package com.ibm.icu.dev.test.bidi;
import java.util.Arrays;
import com.ibm.icu.impl.Utility;
import com.ibm.icu.text.Bidi;
import com.ibm.icu.text.BidiRun;
/**
* Regression test for Bidi multiple paragraphs
*
* @author Lina Kemmel, Matitiahu Allouche
*/
public class TestMultipleParagraphs extends BidiTest {
private static final String text =
"__ABC\u001c" /* Para #0 offset 0 */
+ "__\u05d0DE\u001c" /* 1 6 */
+ "__123\u001c" /* 2 12 */
+ "\r\n" /* 3 18 */
+ "FG\r" /* 4 20 */
+ "\r" /* 5 23 */
+ "HI\r\n" /* 6 24 */
+ "\r\n" /* 7 28 */
+ "\n" /* 8 30 */
+ "\n" /* 9 31 */
+ "JK\u001c"; /* 10 32 */
private static final int paraCount = 11;
private static final int[] paraBounds = {
0, 6, 12, 18, 20, 23, 24, 28, 30, 31, 32, 35
};
private static final byte[] paraLevels = {
Bidi.LTR, Bidi.RTL, Bidi.LEVEL_DEFAULT_LTR, Bidi.LEVEL_DEFAULT_RTL, 22, 23
};
private static final byte[][] multiLevels = {
{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
{0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0},
{22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22},
{23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23}
};
private static final String text2 = "\u05d0 1-2\u001c\u0630 1-2\u001c1-2";
private static final byte[] levels2 = {
1, 1, 2, 2, 2, 0, 1, 1, 2, 1, 2, 0, 2, 2, 2
};
private static final char[] multiparaTestString = {
0x5de, 0x5e0, 0x5e1, 0x5d4, 0x20, 0x5e1, 0x5e4, 0x5da,
0x20, 0xa, 0xa, 0x41, 0x72, 0x74, 0x69, 0x73,
0x74, 0x3a, 0x20, 0x5de, 0x5e0, 0x5e1, 0x5d4, 0x20,
0x5e1, 0x5e4, 0x5da, 0x20, 0xa, 0xa, 0x41, 0x6c,
0x62, 0x75, 0x6d, 0x3a, 0x20, 0x5de, 0x5e0, 0x5e1,
0x5d4, 0x20, 0x5e1, 0x5e4, 0x5da, 0x20, 0xa, 0xa,
0x54, 0x69, 0x6d, 0x65, 0x3a, 0x20, 0x32, 0x3a,
0x32, 0x37, 0xa, 0xa
};
private static final byte[] multiparaTestLevels = {
1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 1, 1, 1, 1, 1,
1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 1, 1, 1,
1, 1, 1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0
};
public void testMultipleParagraphs()
{
byte gotLevel;
byte[] gotLevels;
boolean orderParagraphsLTR;
String src;
Bidi bidi = new Bidi();
Bidi bidiLine;
int count, paraStart, paraLimit, paraIndex, length;
int i, j, k;
logln("\nEntering TestMultipleParagraphs\n");
try {
bidi.setPara(text, Bidi.LTR, null);
} catch (IllegalArgumentException e) {
errln("1st Bidi.setPara failed, paraLevel = " + Bidi.LTR);
}
/* check paragraph count and boundaries */
if (paraCount != (count = bidi.countParagraphs())) {
errln("1st Bidi.countParagraphs returned " + count + ", should be " +
paraCount);
}
BidiRun run;
for (i = 0; i < paraCount; i++) {
run = bidi.getParagraphByIndex(i);
paraStart = run.getStart();
paraLimit = run.getLimit();
if ((paraStart != paraBounds[i]) ||
(paraLimit != paraBounds[i + 1])) {
errln("Found boundaries of paragraph " + i + ": " +
paraStart + "-" + paraLimit + "; expected: " +
paraBounds[i] + "-" + paraBounds[i + 1]);
}
}
/* check with last paragraph not terminated by B */
char[] chars = text.toCharArray();
chars[chars.length - 1] = 'L';
src = new String(chars);
try {
bidi.setPara(src, Bidi.LTR, null);
} catch (IllegalArgumentException e) {
errln("2nd Bidi.setPara failed, paraLevel = " + Bidi.LTR);
}
if (paraCount != (count = bidi.countParagraphs())) {
errln("2nd Bidi.countParagraphs returned " + count +
", should be " + paraCount);
}
i = paraCount - 1;
run = bidi.getParagraphByIndex(i);
paraStart = run.getStart();
paraLimit = run.getLimit();
if ((paraStart != paraBounds[i]) ||
(paraLimit != paraBounds[i + 1])) {
errln("2nd Found boundaries of paragraph " + i + ": " +
paraStart + "-" + paraLimit + "; expected: " +
paraBounds[i] + "-" + paraBounds[i + 1]);
}
/* check paraLevel for all paragraphs under various paraLevel specs */
for (k = 0; k < 6; k++) {
try {
bidi.setPara(src, paraLevels[k], null);
} catch (IllegalArgumentException e) {
errln("3nd Bidi.setPara failed, paraLevel = " + paraLevels[k]);
}
for (i = 0; i < paraCount; i++) {
paraIndex = bidi.getParagraphIndex(paraBounds[i]);
run = bidi.getParagraph(paraBounds[i]);
if (paraIndex != i) {
errln("#1 For paraLevel = " + paraLevels[k] +
" paragraph = " + i + ", found paragraph" +
" index = " + paraIndex + " expected = " + i);
}
gotLevel = run.getEmbeddingLevel();
if (gotLevel != multiLevels[k][i]) {
errln("#2 For paraLevel = " + paraLevels[k] +
" paragraph = " + i + ", found level = " + gotLevel +
", expected = " + multiLevels[k][i]);
}
}
gotLevel = bidi.getParaLevel();
if (gotLevel != multiLevels[k][0]) {
errln("#3 For paraLevel = " + paraLevels[k] +
" getParaLevel = " + gotLevel + ", expected " +
multiLevels[k][0]);
}
}
/* check that the result of Bidi.getParaLevel changes if the first
* paragraph has a different level
*/
chars[0] = '\u05d2'; /* Hebrew letter Gimel */
src = new String(chars);
try {
bidi.setPara(src, Bidi.LEVEL_DEFAULT_LTR, null);
} catch (IllegalArgumentException e) {
errln("Bidi.setPara failed, paraLevel = " + Bidi.LEVEL_DEFAULT_LTR);
}
gotLevel = bidi.getParaLevel();
if (gotLevel != Bidi.RTL) {
errln("#4 For paraLevel = Bidi.LEVEL_DEFAULT_LTR getParaLevel = " +
gotLevel + ", expected = " + Bidi.RTL);
}
/* check that line cannot overlap paragraph boundaries */
bidiLine = new Bidi();
i = paraBounds[1];
k = paraBounds[2] + 1;
try {
bidiLine = bidi.setLine(i, k);
errln("For line limits " + i + "-" + k
+ " got success, while expected failure");
} catch (Exception e) {}
i = paraBounds[1];
k = paraBounds[2];
try {
bidiLine = bidi.setLine(i, k);
} catch (Exception e) {
errln("For line limits " + i + "-" + k + " got failure");
}
/* check level of block separator at end of paragraph when orderParagraphsLTR==FALSE */
try {
bidi.setPara(src, Bidi.RTL, null);
} catch (IllegalArgumentException e) {
errln("Bidi.setPara failed, paraLevel = " + Bidi.RTL);
}
/* get levels through para Bidi block */
try {
gotLevels = bidi.getLevels();
} catch (Exception e) {
errln("Error on Bidi.getLevels");
gotLevels = new byte[bidi.getLength()];
Arrays.fill(gotLevels, (byte)-1);
}
for (i = 26; i < 32; i++) {
if (gotLevels[i] != Bidi.RTL) {
errln("For char " + i + "(0x" + Utility.hex(chars[i]) +
"), level = " + gotLevels[i] + ", expected = " + Bidi.RTL);
}
}
/* get levels through para Line block */
i = paraBounds[1];
k = paraBounds[2];
try {
bidiLine = bidi.setLine(i, k);
} catch (Exception e) {
errln("For line limits " + i + "-" + k + " got failure");
return;
}
paraIndex = bidiLine.getParagraphIndex(i);
run = bidiLine.getParagraph(i);
try {
gotLevels = bidiLine.getLevels();
} catch (Exception e) {
errln("Error on bidiLine.getLevels");
gotLevels = new byte[bidiLine.getLength()];
Arrays.fill(gotLevels, (byte)-1);
}
length = bidiLine.getLength();
gotLevel = run.getEmbeddingLevel();
if ((gotLevel != Bidi.RTL) || (gotLevels[length - 1] != Bidi.RTL)) {
errln("For paragraph " + paraIndex + " with limits " +
run.getStart() + "-" + run.getLimit() +
", paraLevel = " + gotLevel +
"expected = " + Bidi.RTL +
", level of separator = " + gotLevels[length - 1] +
" expected = " + Bidi.RTL);
}
orderParagraphsLTR = bidi.isOrderParagraphsLTR();
assertFalse("orderParagraphsLTR is true", orderParagraphsLTR);
bidi.orderParagraphsLTR(true);
orderParagraphsLTR = bidi.isOrderParagraphsLTR();
assertTrue("orderParagraphsLTR is false", orderParagraphsLTR);
/* check level of block separator at end of paragraph when orderParagraphsLTR==TRUE */
try {
bidi.setPara(src, Bidi.RTL, null);
} catch (IllegalArgumentException e) {
errln("Bidi.setPara failed, paraLevel = " + Bidi.RTL);
}
/* get levels through para Bidi block */
try {
gotLevels = bidi.getLevels();
} catch (Exception e) {
errln("Error on Bidi.getLevels");
gotLevels = new byte[bidi.getLength()];
Arrays.fill(gotLevels, (byte)-1);
}
for (i = 26; i < 32; i++) {
if (gotLevels[i] != 0) {
errln("For char " + i + "(0x" + Utility.hex(chars[i]) +
"), level = "+ gotLevels[i] + ", expected = 0");
}
}
/* get levels through para Line block */
i = paraBounds[1];
k = paraBounds[2];
paraStart = run.getStart();
paraLimit = run.getLimit();
try {
bidiLine = bidi.setLine(paraStart, paraLimit);
} catch (Exception e) {
errln("For line limits " + paraStart + "-" + paraLimit +
" got failure");
}
paraIndex = bidiLine.getParagraphIndex(i);
run = bidiLine.getParagraph(i);
try {
gotLevels = bidiLine.getLevels();
} catch (Exception e) {
errln("Error on bidiLine.getLevels");
gotLevels = new byte[bidiLine.getLength()];
Arrays.fill(gotLevels, (byte)-1);
}
length = bidiLine.getLength();
gotLevel = run.getEmbeddingLevel();
if ((gotLevel != Bidi.RTL) || (gotLevels[length - 1] != 0)) {
err("\nFor paragraph " + paraIndex + " with limits " +
run.getStart() + "-" + run.getLimit() +
", paraLevel = " + gotLevel + "expected = " + Bidi.RTL +
", level of separator = " + gotLevels[length - 1] +
" expected = 0\nlevels = ");
for (count = 0; count < length; count++) {
errcont(gotLevels[count] + " ");
}
errcont("\n");
}
/* test that the concatenation of separate invocations of the bidi code
* on each individual paragraph in order matches the levels array that
* results from invoking bidi once over the entire multiparagraph tests
* (with orderParagraphsLTR false, of course)
*/
src = text; /* restore original content */
bidi.orderParagraphsLTR(false);
try {
bidi.setPara(src, Bidi.LEVEL_DEFAULT_RTL, null);
} catch (IllegalArgumentException e) {
errln("Bidi.setPara failed, paraLevel = " + Bidi.LEVEL_DEFAULT_RTL);
}
try {
gotLevels = bidi.getLevels();
} catch (Exception e) {
errln("Error on bidiLine.getLevels");
gotLevels = new byte[bidi.getLength()];
Arrays.fill(gotLevels, (byte)-1);
}
for (i = 0; i < paraCount; i++) {
/* use pLine for individual paragraphs */
paraStart = paraBounds[i];
length = paraBounds[i + 1] - paraStart;
try {
bidiLine.setPara(src.substring(paraStart, paraStart + length),
Bidi.LEVEL_DEFAULT_RTL, null);
} catch (IllegalArgumentException e) {
errln("Bidi.setPara failed, paraLevel = " + Bidi.LEVEL_DEFAULT_RTL);
}
for (j = 0; j < length; j++) {
if ((k = bidiLine.getLevelAt(j)) !=
(gotLevel = gotLevels[paraStart + j])) {
errln("Checking paragraph concatenation: for paragraph[" +
i + "], char[" + j + "] = 0x" +
Utility.hex(src.charAt(paraStart + j)) +
", level = " + k + ", expected = " + gotLevel);
}
}
}
/* ensure that leading numerics in a paragraph are not treated as arabic
numerals because of arabic text in a preceding paragraph
*/
src = text2;
bidi.orderParagraphsLTR(true);
try {
bidi.setPara(src, Bidi.RTL, null);
} catch (IllegalArgumentException e) {
errln("Bidi.setPara failed, paraLevel = " + Bidi.RTL);
}
try {
gotLevels = bidi.getLevels();
} catch (Exception e) {
errln("Error on Bidi.getLevels");
gotLevels = new byte[bidi.getLength()];
Arrays.fill(gotLevels, (byte)-1);
}
for (i = 0, length = src.length(); i < length; i++) {
if (gotLevels[i] != levels2[i]) {
errln("Checking leading numerics: for char " + i + "(0x" +
Utility.hex(src.charAt(i)) + "), level = " +
gotLevels[i] + ", expected = " + levels2[i]);
}
}
/* check handling of whitespace before end of paragraph separator when
* orderParagraphsLTR==TRUE, when last paragraph has, and lacks, a terminating B
*/
chars = src.toCharArray();
Arrays.fill(chars, '\u0020');
bidi.orderParagraphsLTR(true);
for (i = 0x001c; i <= 0x0020; i += (0x0020-0x001c)) {
chars[4] = (char)i; /* with and without terminating B */
for (j = 0x0041; j <= 0x05d0; j += (0x05d0-0x0041)) {
chars[0] = (char)j; /* leading 'A' or Alef */
src = new String(chars);
for (gotLevel = 4; gotLevel <= 5; gotLevel++) {
/* test even and odd paraLevel */
try {
bidi.setPara(src, gotLevel, null);
} catch (IllegalArgumentException e) {
errln("Bidi.setPara failed, paraLevel = " + gotLevel);
}
try {
gotLevels = bidi.getLevels();
} catch (Exception e) {
errln("Error on Bidi.getLevels");
gotLevels = new byte[bidi.getLength()];
Arrays.fill(gotLevels, (byte)-1);
}
for (k = 1; k <= 3; k++) {
if (gotLevels[k] != gotLevel) {
errln("Checking trailing spaces for leading char 0x" +
Utility.hex(chars[0]) + ", last_char = " +
Utility.hex(chars[4]) + ", index = " + k +
"level = " + gotLevels[k] +
", expected = " + gotLevel);
}
}
}
}
}
/* check default orientation when inverse bidi and paragraph starts
* with LTR strong char and ends with RTL strong char, with and without
* a terminating B
*/
bidi.setReorderingMode(Bidi.REORDER_INVERSE_LIKE_DIRECT);
bidi.setPara("abc \u05d2\u05d1\n", Bidi.LEVEL_DEFAULT_LTR, null);
String out = bidi.writeReordered(0);
assertEquals("\nInvalid output", "\u05d1\u05d2 abc\n", out);
bidi.setPara("abc \u05d2\u05d1", Bidi.LEVEL_DEFAULT_LTR, null);
out = bidi.writeReordered(0);
assertEquals("\nInvalid output #1", "\u05d1\u05d2 abc", out);
/* check multiple paragraphs together with explicit levels
*/
bidi.setReorderingMode(Bidi.REORDER_DEFAULT);
gotLevels = new byte[] {0,0,0,0,0,0,0,0,0,0};
bidi.setPara("ab\u05d1\u05d2\n\u05d3\u05d4123", Bidi.LTR, gotLevels);
out = bidi.writeReordered(0);
assertEquals("\nInvalid output #2", "ab\u05d2\u05d1\n123\u05d4\u05d3", out);
assertEquals("\nInvalid number of paras", 2, bidi.countParagraphs());
logln("\nExiting TestMultipleParagraphs\n");
/* check levels in multiple paragraphs with default para level
*/
bidi = new Bidi();
bidi.setPara(multiparaTestString, Bidi.LEVEL_DEFAULT_LTR, null);
try {
gotLevels = bidi.getLevels();
} catch (Exception e) {
errln("Error on Bidi.getLevels for multiparaTestString");
return;
}
for (i = 0; i < multiparaTestString.length; i++) {
if (gotLevels[i] != multiparaTestLevels[i]) {
errln("Error on level for multiparaTestString at index " + i +
", expected=" + multiparaTestLevels[i] +
", actual=" + gotLevels[i]);
}
}
}
public static void main(String[] args) {
try {
new TestMultipleParagraphs().run(args);
}
catch (Exception e) {
System.out.println(e);
}
}
}