private void DoTests(Bidi bidi, Bidi bidiLine, bool countRunsFirst)
{
int testNumber;
String str0;
int lineStart;
sbyte paraLevel;
int bidiTestCount = IBM.ICU.Charset.TestData.TestCount();
for (testNumber = 0; testNumber < bidiTestCount; ++testNumber)
{
TestData test = IBM.ICU.Charset.TestData.GetTestData(testNumber);
str0 = GetStringFromDirProps(test.dirProps);
paraLevel = test.paraLevel;
try {
bidi.SetPara(str0, paraLevel, null);
Logln("Bidi.setPara(tests[" + testNumber + "] OK, direction "
+ bidi.GetDirection() + " paraLevel " + paraLevel);
} catch (Exception e) {
Errln("Bidi.setPara(tests[" + testNumber
+ "] failed, direction " + bidi.GetDirection()
+ " paraLevel " + paraLevel);
}
lineStart = test.lineStart;
if (lineStart == -1)
{
DoTest(bidi, testNumber, test, 0, countRunsFirst);
}
else
{
try {
bidiLine = bidi.SetLine(lineStart, test.lineLimit);
Logln("Bidi.setLine(" + lineStart + ", " + test.lineLimit
+ "), in tests[" + testNumber + "] OK, direction "
+ bidiLine.GetDirection() + " paraLevel "
+ bidiLine.GetBaseLevel());
DoTest(bidiLine, testNumber, test, lineStart,
countRunsFirst);
} catch (Exception e_0) {
Errln("Bidi.setLine(" + lineStart + ", " + test.lineLimit
+ "), in runAll test[" + testNumber + "] failed");
}
/* do it again using createLineBidi instead of setLine */
try {
bidiLine = bidi.CreateLineBidi(lineStart, test.lineLimit);
Logln("Bidi.createLineBidi(" + lineStart + ", "
+ test.lineLimit + "), in tests[" + testNumber
+ "] OK, direction " + bidiLine.GetDirection()
+ " paraLevel " + bidiLine.GetBaseLevel());
DoTest(bidiLine, testNumber, test, lineStart,
countRunsFirst);
} catch (Exception e_1) {
Errln("Bidi.createLineBidi(" + lineStart + ", "
+ test.lineLimit + "), in runAll test["
+ testNumber + "] failed");
}
}
}
}
internal void PrintCaseInfo(Bidi bidi, String src, String dst)
{
int length = bidi.GetProcessedLength();
sbyte[] levels = bidi.GetLevels();
char[] levelChars = new char[length];
sbyte lev;
int runCount = bidi.CountRuns();
Errcontln("========================================");
Errcontln("Processed length: " + length);
for (int i = 0; i < length; i++)
{
lev = levels[i];
if (lev < 0)
{
levelChars[i] = '-';
}
else if (lev < columns.Length)
{
levelChars[i] = columns[lev];
}
else
{
levelChars[i] = '+';
}
}
Errcontln("Levels: " + ILOG.J2CsMapping.Util.StringUtil.NewString(levelChars));
Errcontln("Source: " + src);
Errcontln("Result: " + dst);
Errcontln("Direction: " + bidi.GetDirection());
Errcontln("paraLevel: " + bidi.GetParaLevel().ToString());
Errcontln("reorderingMode: " + ModeToString(bidi.GetReorderingMode()));
Errcontln("reorderingOptions: "
+ SpOptionsToString(bidi.GetReorderingOptions()));
Errcont("Runs: " + runCount + " => logicalStart.length/level: ");
for (int i_0 = 0; i_0 < runCount; i_0++)
{
BidiRun run;
run = bidi.GetVisualRun(i_0);
Errcont(" " + run.GetStart() + "." + run.GetLength() + "/"
+ run.GetEmbeddingLevel());
}
Errcont("\n");
}
public void TestFailureRecovery2()
{
Logln("\nEntering TestFailureRecovery\n");
Bidi bidi = new Bidi();
try
{
bidi.SetPara("abc", (sbyte)(IBM.ICU.Text.Bidi.LEVEL_DEFAULT_LTR - 1), null);
Errln("Bidi.setPara did not fail when passed too big para level");
}
catch (ArgumentException e)
{
Logln("OK: Got exception for bidi.setPara(..., Bidi.LEVEL_DEFAULT_LTR - 1, ...)"
+ " as expected: " + e.Message);
}
try
{
bidi.SetPara("abc", (sbyte)(-1), null);
Errln("Bidi.setPara did not fail when passed negative para level");
}
catch (ArgumentException e_0)
{
Logln("OK: Got exception for bidi.setPara(..., -1, ...)"
+ " as expected: " + e_0.Message);
}
try
{
IBM.ICU.Text.Bidi.WriteReverse(null, 0);
Errln("Bidi.writeReverse did not fail when passed a null string");
}
catch (ArgumentException e_1)
{
Logln("OK: Got exception for Bidi.writeReverse(null) as expected: "
+ e_1.Message);
}
bidi = new Bidi();
try
{
bidi.SetLine(0, 1);
Errln("bidi.setLine did not fail when called before valid setPara()");
}
catch (InvalidOperationException e_2)
{
Logln("OK: Got exception for Bidi.setLine(0, 1) as expected: "
+ e_2.Message);
}
try
{
bidi.GetDirection();
Errln("bidi.getDirection did not fail when called before valid setPara()");
}
catch (InvalidOperationException e_3)
{
Logln("OK: Got exception for Bidi.getDirection() as expected: "
+ e_3.Message);
}
bidi.SetPara("abc", IBM.ICU.Text.Bidi.LTR, null);
try
{
bidi.GetLevelAt(3);
Errln("bidi.getLevelAt did not fail when called with bad argument");
}
catch (ArgumentException e_4)
{
Logln("OK: Got exception for Bidi.getLevelAt(3) as expected: "
+ e_4.Message);
}
try
{
bidi = new Bidi(-1, 0);
Errln("Bidi constructor did not fail when called with bad argument");
}
catch (ArgumentException e_5)
{
Logln("OK: Got exception for Bidi(-1,0) as expected: "
+ e_5.Message);
}
bidi = new Bidi(2, 1);
try
{
bidi.SetPara("abc", IBM.ICU.Text.Bidi.LTR, null);
Errln("setPara did not fail when called with text too long");
}
catch (Exception e_6)
{
Logln("OK: Got exception for setPara(\"abc\") as expected: "
+ e_6.Message);
}
try
{
bidi.SetPara("=2", IBM.ICU.Text.Bidi.RTL, null);
bidi.CountRuns();
Errln("countRuns did not fail when called for too many runs");
}
catch (Exception e_7)
{
Logln("OK: Got exception for countRuns as expected: "
+ e_7.Message);
}
int rm = bidi.GetReorderingMode();
bidi.SetReorderingMode(IBM.ICU.Text.Bidi.REORDER_DEFAULT - 1);
if (rm != bidi.GetReorderingMode())
{
Errln("setReorderingMode with bad argument #1 should have no effect");
}
bidi.SetReorderingMode(9999);
if (rm != bidi.GetReorderingMode())
{
Errln("setReorderingMode with bad argument #2 should have no effect");
}
/* Try a surrogate char */
bidi = new Bidi();
bidi.SetPara("\uD800\uDC00", IBM.ICU.Text.Bidi.RTL, null);
if (bidi.GetDirection() != IBM.ICU.Text.Bidi.MIXED)
{
Errln("getDirection for 1st surrogate char should be MIXED");
}
sbyte[] levels = new sbyte[] { 6, 5, 4 };
try
{
bidi.SetPara("abc", (sbyte)5, levels);
Errln("setPara did not fail when called with bad levels");
}
catch (ArgumentException e_8)
{
Logln("OK: Got exception for setPara(..., levels) as expected: "
+ e_8.Message);
}
Logln("\nExiting TestFailureRecovery\n");
}
private void DoMisc()
{
/* Miscellaneous tests to exercize less popular code paths */
Bidi bidi = new Bidi(120, 66), bidiLine;
AssertEquals("\nwriteReverse should return an empty string", "",
IBM.ICU.Text.Bidi.WriteReverse("", 0));
bidi.SetPara("", IBM.ICU.Text.Bidi.LTR, null);
AssertEquals("\nwriteReordered should return an empty string", "",
bidi.WriteReordered(0));
bidi.SetPara("abc", IBM.ICU.Text.Bidi.LTR, null);
AssertEquals("\ngetRunStart should return 0", 0, bidi.GetRunStart(0));
AssertEquals("\ngetRunLimit should return 3", 3, bidi.GetRunLimit(0));
bidi.SetPara("abc ", IBM.ICU.Text.Bidi.RTL, null);
bidiLine = bidi.SetLine(0, 6);
for (int i = 3; i < 6; i++)
{
AssertEquals("\nTrailing space at " + i
+ " should get paragraph level", IBM.ICU.Text.Bidi.RTL,
bidiLine.GetLevelAt(i));
}
bidi.SetPara("abc def", IBM.ICU.Text.Bidi.RTL, null);
bidiLine = bidi.SetLine(0, 6);
for (int i_0 = 3; i_0 < 6; i_0++)
{
AssertEquals("\nTrailing space at " + i_0
+ " should get paragraph level", IBM.ICU.Text.Bidi.RTL,
bidiLine.GetLevelAt(i_0));
}
bidi.SetPara("abcdefghi ", IBM.ICU.Text.Bidi.RTL, null);
bidiLine = bidi.SetLine(0, 6);
for (int i_1 = 3; i_1 < 6; i_1++)
{
AssertEquals("\nTrailing char at " + i_1 + " should get level 2", 2,
bidiLine.GetLevelAt(i_1));
}
bidi.SetReorderingOptions(IBM.ICU.Text.Bidi.OPTION_REMOVE_CONTROLS);
bidi.SetPara("\u200eabc def", IBM.ICU.Text.Bidi.RTL, null);
bidiLine = bidi.SetLine(0, 6);
AssertEquals("\nWrong result length", 5, bidiLine.GetResultLength());
bidi.SetPara("abcdefghi", IBM.ICU.Text.Bidi.LTR, null);
bidiLine = bidi.SetLine(0, 6);
AssertEquals("\nWrong direction #1", IBM.ICU.Text.Bidi.LTR, bidiLine.GetDirection());
bidi.SetPara("", IBM.ICU.Text.Bidi.LTR, null);
sbyte[] levels = bidi.GetLevels();
AssertEquals("\nWrong number of level elements", 0, levels.Length);
AssertEquals("\nWrong number of runs #1", 0, bidi.CountRuns());
bidi.SetPara(" ", IBM.ICU.Text.Bidi.RTL, null);
bidiLine = bidi.SetLine(0, 6);
AssertEquals("\nWrong number of runs #2", 1, bidiLine.CountRuns());
bidi.SetPara("a\u05d0 bc", IBM.ICU.Text.Bidi.RTL, null);
bidiLine = bidi.SetLine(0, 6);
AssertEquals("\nWrong direction #2", IBM.ICU.Text.Bidi.MIXED, bidi.GetDirection());
AssertEquals("\nWrong direction #3", IBM.ICU.Text.Bidi.MIXED,
bidiLine.GetDirection());
AssertEquals("\nWrong number of runs #3", 2, bidiLine.CountRuns());
int[] map = IBM.ICU.Text.Bidi.ReorderLogical(null);
AssertTrue("\nWe should have got a null map #1", map == null);
map = IBM.ICU.Text.Bidi.ReorderLogical(new sbyte[] { 0, 99, 99 });
AssertTrue("\nWe should have got a null map #2", map == null);
map = IBM.ICU.Text.Bidi.ReorderVisual(null);
AssertTrue("\nWe should have got a null map #3", map == null);
map = IBM.ICU.Text.Bidi.InvertMap(null);
AssertTrue("\nWe should have got a null map #4", map == null);
map = IBM.ICU.Text.Bidi.InvertMap(new int[] { 0, 1, -1, 5, 4 });
AssertTrue("\nUnexpected inverted Map",
ILOG.J2CsMapping.Collections.Arrays.Equals(map, new int[] { 0, 1, -1, -1, 4, 3 }));
bidi.SetPara("", IBM.ICU.Text.Bidi.LTR, null);
map = bidi.GetLogicalMap();
AssertTrue("\nMap should have length==0 #1", map.Length == 0);
map = bidi.GetVisualMap();
AssertTrue("\nMap should have length==0 #2", map.Length == 0);
/* test BidiRun.toString and allocation of run memory > 1 */
bidi.SetPara("abc", IBM.ICU.Text.Bidi.LTR, null);
AssertEquals("\nWrong run display", "BidiRun 0 - 3 @ 0", bidi
.GetLogicalRun(0).ToString());
/* test REMOVE_BIDI_CONTROLS together with DO_MIRRORING */
bidi.SetPara("abc\u200e", IBM.ICU.Text.Bidi.LTR, null);
String xout = bidi.WriteReordered(IBM.ICU.Text.Bidi.REMOVE_BIDI_CONTROLS
| IBM.ICU.Text.Bidi.DO_MIRRORING);
AssertEquals("\nWrong result #1", "abc", xout);
/* test inverse Bidi with marks and contextual orientation */
bidi.SetReorderingMode(IBM.ICU.Text.Bidi.REORDER_INVERSE_LIKE_DIRECT);
bidi.SetReorderingOptions(IBM.ICU.Text.Bidi.OPTION_INSERT_MARKS);
bidi.SetPara("", IBM.ICU.Text.Bidi.LEVEL_DEFAULT_RTL, null);
xout = bidi.WriteReordered(0);
AssertEquals("\nWrong result #2", "", xout);
bidi.SetPara(" ", IBM.ICU.Text.Bidi.LEVEL_DEFAULT_RTL, null);
xout = bidi.WriteReordered(0);
AssertEquals("\nWrong result #3", " ", xout);
bidi.SetPara("abc", IBM.ICU.Text.Bidi.LEVEL_DEFAULT_RTL, null);
xout = bidi.WriteReordered(0);
AssertEquals("\nWrong result #4", "abc", xout);
bidi.SetPara("\u05d0\u05d1", IBM.ICU.Text.Bidi.LEVEL_DEFAULT_RTL, null);
xout = bidi.WriteReordered(0);
AssertEquals("\nWrong result #5", "\u05d1\u05d0", xout);
bidi.SetPara("abc \u05d0\u05d1", IBM.ICU.Text.Bidi.LEVEL_DEFAULT_RTL, null);
xout = bidi.WriteReordered(0);
AssertEquals("\nWrong result #6", "\u05d1\u05d0 abc", xout);
bidi.SetPara("\u05d0\u05d1 abc", IBM.ICU.Text.Bidi.LEVEL_DEFAULT_RTL, null);
xout = bidi.WriteReordered(0);
AssertEquals("\nWrong result #7", "\u200fabc \u05d1\u05d0", xout);
bidi.SetPara("\u05d0\u05d1 abc .-=", IBM.ICU.Text.Bidi.LEVEL_DEFAULT_RTL, null);
xout = bidi.WriteReordered(0);
AssertEquals("\nWrong result #8", "\u200f=-. abc \u05d1\u05d0", xout);
bidi.OrderParagraphsLTR(true);
bidi.SetPara("\n\r \n\rabc\n\u05d0\u05d1\rabc \u05d2\u05d3\n\r"
+ "\u05d4\u05d5 abc\n\u05d6\u05d7 abc .-=\r\n"
+ "-* \u05d8\u05d9 abc .-=", IBM.ICU.Text.Bidi.LEVEL_DEFAULT_RTL, null);
xout = bidi.WriteReordered(0);
AssertEquals(
"\nWrong result #9",
"\n\r \n\rabc\n\u05d1\u05d0\r\u05d3\u05d2 abc\n\r"
+ "\u200fabc \u05d5\u05d4\n\u200f=-. abc \u05d7\u05d6\r\n"
+ "\u200f=-. abc \u05d9\u05d8 *-", xout);
bidi.SetPara("\u05d0 \t", IBM.ICU.Text.Bidi.LTR, null);
xout = bidi.WriteReordered(0);
AssertEquals("\nWrong result #10", "\u05D0\u200e \t", xout);
bidi.SetPara("\u05d0 123 \t\u05d1 123 \u05d2", IBM.ICU.Text.Bidi.LTR, null);
xout = bidi.WriteReordered(0);
AssertEquals("\nWrong result #11",
"\u05d0 \u200e123\u200e \t\u05d2 123 \u05d1", xout);
bidi.SetPara("\u05d0 123 \u0660\u0661 ab", IBM.ICU.Text.Bidi.LTR, null);
xout = bidi.WriteReordered(0);
AssertEquals("\nWrong result #12",
"\u05d0 \u200e123 \u200e\u0660\u0661 ab", xout);
bidi.SetPara("ab \t", IBM.ICU.Text.Bidi.RTL, null);
xout = bidi.WriteReordered(0);
AssertEquals("\nWrong result #13", "\u200f\t ab", xout);
/* check exceeding para level */
bidi = new Bidi();
bidi.SetPara("A\u202a\u05d0\u202aC\u202c\u05d1\u202cE",
(sbyte)(IBM.ICU.Text.Bidi.MAX_EXPLICIT_LEVEL - 1), null);
AssertEquals("\nWrong level at index 2", 61, bidi.GetLevelAt(2));
/* check 1-char runs with RUNS_ONLY */
bidi.SetReorderingMode(IBM.ICU.Text.Bidi.REORDER_RUNS_ONLY);
bidi.SetPara("a \u05d0 b \u05d1 c \u05d2 d ", IBM.ICU.Text.Bidi.LTR, null);
AssertEquals("\nWrong number of runs #4", 14, bidi.CountRuns());
}
private void DoTest(Bidi bidi, int testNumber, TestData test,
int lineStart, bool countRunsFirst)
{
short[] dirProps = test.dirProps;
byte[] levels = test.levels;
int[] visualMap = test.visualMap;
int i, len = bidi.GetLength(), logicalIndex = -1, runCount = 0;
sbyte level, level2;
if (countRunsFirst)
{
Logln("Calling Bidi.countRuns() first.");
try {
runCount = bidi.CountRuns();
} catch (InvalidOperationException e) {
Errln("Bidi.countRuns(test[" + testNumber + "]) failed");
}
}
else
{
Logln("Calling Bidi.getLogicalMap() first.");
}
_testReordering(bidi, testNumber);
for (i = 0; i < len; ++i)
{
Logln(i + " " + bidi.GetLevelAt(i) + " " + levelString
+ IBM.ICU.Charset.TestData.dirPropNames[dirProps[lineStart + i]] + " "
+ bidi.GetVisualIndex(i));
}
Log("\n-----levels:");
for (i = 0; i < len; ++i)
{
if (i > 0)
{
Log(",");
}
Log(" " + bidi.GetLevelAt(i));
}
Log("\n--reordered:");
for (i = 0; i < len; ++i)
{
if (i > 0)
{
Log(",");
}
Log(" " + bidi.GetVisualIndex(i));
}
Log("\n");
AssertEquals(
"\nFailure in Bidi.getDirection(test[" + testNumber + "])",
test.direction, bidi.GetDirection());
AssertEquals(
"\nFailure in Bidi.getParaLevel(test[" + testNumber + "])",
test.resultLevel, bidi.GetParaLevel());
for (i = 0; i < len; ++i)
{
AssertEquals("\nFailure in Bidi.getLevelAt(" + i + ") in test["
+ testNumber + "]", levels[i], bidi.GetLevelAt(i));
}
for (i = 0; i < len; ++i)
{
try {
logicalIndex = bidi.GetVisualIndex(i);
} catch (Exception th) {
Errln("Bidi.getVisualIndex(" + i + ") in test[" + testNumber
+ "] failed");
}
if (visualMap[i] != logicalIndex)
{
AssertEquals("\nFailure in Bidi.getVisualIndex(" + i
+ ") in test[" + testNumber + "])", visualMap[i],
logicalIndex);
}
}
if (!countRunsFirst)
{
try {
runCount = bidi.CountRuns();
} catch (InvalidOperationException e_0) {
Errln("Bidi.countRuns(test[" + testNumber + "]) failed");
}
}
BidiRun run;
for (logicalIndex = 0; logicalIndex < len;)
{
level = bidi.GetLevelAt(logicalIndex);
run = bidi.GetLogicalRun(logicalIndex);
logicalIndex = run.GetLimit();
level2 = run.GetEmbeddingLevel();
AssertEquals("Logical " + run.ToString() + " in test[" + testNumber
+ "]: wrong level", level, level2);
if (--runCount < 0)
{
Errln("Bidi.getLogicalRun(test["
+ testNumber
+ "]): wrong number of runs compared to Bidi.countRuns() = "
+ bidi.CountRuns());
}
}
if (runCount != 0)
{
Errln("Bidi.getLogicalRun(test["
+ testNumber
+ "]): wrong number of runs compared to Bidi.countRuns() = "
+ bidi.CountRuns());
}
Log("\n\n");
}
public void TestCompatibility2()
{
// This test case does not work well on Java 1.4/1.4.1 environment,
// because of insufficient Bidi implementation in these versions.
/*String javaVersion = System.Environment.GetEnvironmentVariable("java.version");
* if (javaVersion.StartsWith("1.4.0") || javaVersion.StartsWith("1.4.1")) {
* Logln("\nSkipping TestCompatibility. The test case is known to fail on Java "
+ javaVersion + "\n");
+ return;
+ }*/
Logln("\nEntering TestCompatibility\n");
/* check constant field values */
int val;
val = IBM.ICU.Text.Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT;
val = IBM.ICU.Text.Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT;
val = IBM.ICU.Text.Bidi.DIRECTION_LEFT_TO_RIGHT;
val = IBM.ICU.Text.Bidi.DIRECTION_RIGHT_TO_LEFT;
Logln("last val = " + val);
String[] data = { "",
/*
* the following 2 cases are skipped, because java.text.Bidi has bugs
* which cause discrepancies "abc", "ABC",
*/
"abc def", "ABC DEF", "abc 123 def", "ABC 123 DEF", "abc DEF ghi",
"abc DEF 123 xyz","abc GHIJ 12345 def KLM" };
int dataCnt = data.Length;
Bidi bidi;
Bidi jbidi;
for (int i = 0; i < dataCnt; i++)
{
String src = IBM.ICU.Charset.BidiTest.PseudoToU16(data[i]);
bidi = new Bidi(src, IBM.ICU.Text.Bidi.DIRECTION_LEFT_TO_RIGHT);
jbidi = new Bidi(src,
Bidi.DIRECTION_LEFT_TO_RIGHT);
CompareBidi(bidi, jbidi);
bidi = new Bidi(src, IBM.ICU.Text.Bidi.DIRECTION_RIGHT_TO_LEFT);
jbidi = new Bidi(src,
Bidi.DIRECTION_RIGHT_TO_LEFT);
CompareBidi(bidi, jbidi);
char[] chars = src.ToCharArray();
bidi = new Bidi(chars, 0, null, 0, chars.Length,
IBM.ICU.Text.Bidi.DIRECTION_LEFT_TO_RIGHT);
jbidi = new Bidi(chars, 0, null, 0, chars.Length,
Bidi.DIRECTION_LEFT_TO_RIGHT);
CompareBidi(bidi, jbidi);
}
/* check bogus flags */
bidi = new Bidi("abc", 999);
AssertEquals("\nDirection should be LTR", IBM.ICU.Text.Bidi.LTR, bidi.GetDirection());
/* check constructor with overriding embeddings */
bidi = new Bidi(new char[] { 's', 's', 's' }, 0, new sbyte[] {
(sbyte)-7, (sbyte)-2, (sbyte)-3
}, 0, 3,
IBM.ICU.Text.Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
jbidi = new Bidi(new char[] { 's', 's', 's' }, 0,
new sbyte[] { (sbyte)-7, (sbyte)-2, (sbyte)-3 }, 0, 3,
Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
AttributedString al = new AttributedString(
"HEBREW 123 english MOREHEB");
al.AddAttribute(TextAttribute.RUN_DIRECTION,
TextAttribute.RUN_DIRECTION_RTL);
al.AddAttribute(TextAttribute.NUMERIC_SHAPING,
NumericShaper.GetShaper(NumericShaper.ARABIC));
al.AddAttribute(TextAttribute.BIDI_EMBEDDING, 1, 0, 26);
al.AddAttribute(TextAttribute.BIDI_EMBEDDING, -1, 0, 6);
al.AddAttribute(TextAttribute.BIDI_EMBEDDING, -1, 19,
26);
AttributedCharacterIterator aci = al.GetIterator();
bidi = new Bidi(aci);
jbidi = new Bidi(aci);
CompareBidi(bidi, jbidi);
String xout = bidi.WriteReordered(0);
Logln("Output #1 of Bidi(AttributedCharacterIterator): " + xout);
al = new AttributedString("HEBREW 123 english MOREHEB");
al.AddAttribute(TextAttribute.RUN_DIRECTION,
TextAttribute.RUN_DIRECTION_RTL);
al.AddAttribute(TextAttribute.BIDI_EMBEDDING, 0, 0, 26);
aci = al.GetIterator();
bidi = new Bidi(aci);
jbidi = new Bidi(aci);
CompareBidi(bidi, jbidi);
xout = bidi.WriteReordered(0);
Logln("Output #2 of Bidi(AttributedCharacterIterator): " + xout);
al = new AttributedString("HEBREW 123 english MOREHEB");
aci = al.GetIterator();
bidi = new Bidi(aci);
jbidi = new Bidi(aci);
CompareBidi(bidi, jbidi);
xout = bidi.WriteReordered(0);
Logln("Output #3 of Bidi(AttributedCharacterIterator): " + xout);
char[] text = "abc==(123)==>def".ToCharArray();
bidi = new Bidi(text, 3, null, 0, 10,
IBM.ICU.Text.Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
jbidi = new Bidi(text, 3, null, 0, 10,
Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
CompareBidi(bidi, jbidi);
xout = bidi.WriteReordered(0);
Logln("Output of Bidi(abc==(123)==>def,3,null,0,10, DEFAULT_LTR): "
+ xout);
bidi = new Bidi(text, 3, null, 0, 10,
IBM.ICU.Text.Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
jbidi = new Bidi(text, 3, null, 0, 10,
Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
CompareBidi(bidi, jbidi);
xout = bidi.WriteReordered(0);
Logln("Output of Bidi(abc==(123)==>def,3,null,0,10, DEFAULT_RTL): "
+ xout);
sbyte[] levels = new sbyte[] { 0, 0, 0, -1, -1, -1, 0, 0, 0, 0 };
bidi = new Bidi(text, 3, levels, 0, 10, IBM.ICU.Text.Bidi.DIRECTION_LEFT_TO_RIGHT);
jbidi = new Bidi(text, 3, levels, 0, 10,
Bidi.DIRECTION_LEFT_TO_RIGHT);
CompareBidi(bidi, jbidi);
xout = bidi.WriteReordered(0);
Logln("Output of Bidi(abc==(123)==>def,3,levels,0,10, LTR): " + xout);
bidi = new Bidi(text, 3, levels, 0, 10,
IBM.ICU.Text.Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
jbidi = new Bidi(text, 3, levels, 0, 10,
Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
CompareBidi(bidi, jbidi);
xout = bidi.WriteReordered(0);
Logln("Output of Bidi(abc==(123)==>def,3,levels,0,10, DEFAULT_RTL): "
+ xout);
/* test reorderVisually */
sbyte[] myLevels = new sbyte[] { 1, 2, 0, 1, 2, 1, 2, 0, 1, 2 };
object[] objects = new object[10];
levels = new sbyte[objects.Length];
for (int i_0 = 0; i_0 < objects.Length; i_0++)
{
objects[i_0] = (char)((char)('a' + i_0));
levels[i_0] = myLevels[i_0];
}
IBM.ICU.Text.Bidi.ReorderVisually(levels, 3, objects, 3, 7);
String strbidi = "";
for (int i_1 = 0; i_1 < objects.Length; i_1++)
{
strbidi += objects[i_1].ToString();
}
for (int i_2 = 0; i_2 < objects.Length; i_2++)
{
objects[i_2] = (char)((char)('a' + i_2));
levels[i_2] = myLevels[i_2];
}
Bidi.ReorderVisually(levels, 3, objects, 3, 7);
String strjbidi = "";
for (int i_3 = 0; i_3 < objects.Length; i_3++)
{
strjbidi += objects[i_3].ToString();
}
if (!strjbidi.Equals(strbidi))
{
Errln("Discrepancy in reorderVisually " + "\n bidi: "
+ strbidi + "\n jbidi: " + strjbidi);
}
else
{
Logln("Correct match in reorderVisually " + "\n bidi: "
+ strbidi + "\n jbidi: " + strjbidi);
}
Logln("\nExiting TestCompatibility\n");
}
