/*
*******************************************************************************
* Copyright (C) 2001-2007, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
*/
package com.ibm.icu.dev.test.bidi;
import java.util.Arrays;
import com.ibm.icu.lang.UCharacter;
import com.ibm.icu.util.VersionInfo;
import com.ibm.icu.dev.test.TestFmwk;
import com.ibm.icu.impl.Utility;
import com.ibm.icu.text.Bidi;
import com.ibm.icu.text.BidiRun;
/**
* A base class for the Bidi test suite.
*
* @author Lina Kemmel, Matitiahu Allouche
*/
public class BidiTest extends TestFmwk {
protected static final char[] charFromDirProp = {
/* L R EN ES ET AN CS B S WS ON */
0x61, 0x5d0, 0x30, 0x2f, 0x25, 0x660, 0x2c, 0xa, 0x9, 0x20, 0x26,
/* LRE LRO AL RLE RLO PDF NSM BN */
0x202a, 0x202d, 0x627, 0x202b, 0x202e, 0x202c, 0x308, 0x200c
};
static {
initCharFromDirProps();
}
private static void initCharFromDirProps() {
final VersionInfo ucd401 = VersionInfo.getInstance(4, 0, 1, 0);
VersionInfo ucdVersion = VersionInfo.getInstance(0, 0, 0, 0);
/* lazy initialization */
if (ucdVersion.getMajor() > 0) {
return;
}
ucdVersion = UCharacter.getUnicodeVersion();
if (ucdVersion.compareTo(ucd401) >= 0) {
/* Unicode 4.0.1 changes bidi classes for +-/ */
/* change ES character from / to + */
charFromDirProp[TestData.ES] = 0x2b;
}
}
protected boolean assertEquals(String message, String expected, String actual,
String src, String mode, String option,
String level) {
if (expected == null || actual == null) {
return super.assertEquals(message, expected, actual);
}
if (expected.equals(actual)) {
return true;
}
errln("");
errcontln(message);
if (src != null) {
errcontln("source : \"" + Utility.escape(src) + "\"");
}
errcontln("expected : \"" + Utility.escape(expected) + "\"");
errcontln("actual : \"" + Utility.escape(actual) + "\"");
if (mode != null) {
errcontln("reordering mode : " + mode);
}
if (option != null) {
errcontln("reordering option : " + option);
}
if (level != null) {
errcontln("paragraph level : " + level);
}
return false;
}
protected static String valueOf(int[] array) {
StringBuffer result = new StringBuffer(array.length * 4);
for (int i = 0; i < array.length; i++) {
result.append(' ');
result.append(array[i]);
}
return result.toString();
}
private static final String[] modeDescriptions = {
"REORDER_DEFAULT",
"REORDER_NUMBERS_SPECIAL",
"REORDER_GROUP_NUMBERS_WITH_R",
"REORDER_RUNS_ONLY",
"REORDER_INVERSE_NUMBERS_AS_L",
"REORDER_INVERSE_LIKE_DIRECT",
"REORDER_INVERSE_FOR_NUMBERS_SPECIAL"
};
protected static String modeToString(int mode) {
if (mode < Bidi.REORDER_DEFAULT ||
mode > Bidi.REORDER_INVERSE_FOR_NUMBERS_SPECIAL) {
return "INVALID";
}
return modeDescriptions[mode];
}
private static final short SETPARA_MASK = Bidi.OPTION_INSERT_MARKS |
Bidi.OPTION_REMOVE_CONTROLS | Bidi.OPTION_STREAMING;
private static final String[] setParaDescriptions = {
"OPTION_INSERT_MARKS",
"OPTION_REMOVE_CONTROLS",
"OPTION_STREAMING"
};
protected static String spOptionsToString(int option) {
return optionToString(option, SETPARA_MASK, setParaDescriptions);
}
private static final int MAX_WRITE_REORDERED_OPTION = Bidi.OUTPUT_REVERSE;
private static final int REORDER_MASK = (MAX_WRITE_REORDERED_OPTION << 1) - 1;
private static final String[] writeReorderedDescriptions = {
"KEEP_BASE_COMBINING", // 1
"DO_MIRRORING", // 2
"INSERT_LRM_FOR_NUMERIC", // 4
"REMOVE_BIDI_CONTROLS", // 8
"OUTPUT_REVERSE" // 16
};
public static String wrOptionsToString(int option) {
return optionToString(option, REORDER_MASK, writeReorderedDescriptions);
}
public static String optionToString(int option, int mask,
String[] descriptions) {
StringBuffer desc = new StringBuffer(50);
if ((option &= mask) == 0) {
return "0";
}
desc.setLength(0);
for (int i = 0; option > 0; i++, option >>= 1) {
if ((option & 1) != 0) {
if (desc.length() > 0) {
desc.append(" | ");
}
desc.append(descriptions[i]);
}
}
return desc.toString();
}
static final String columnString =
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
static final char[] columns = columnString.toCharArray();
private static final int TABLE_SIZE = 256;
private static boolean tablesInitialized = false;
private static char[] pseudoToUChar;
private static char[] UCharToPseudo; /* used for Unicode chars < 0x0100 */
private static char[] UCharToPseud2; /* used for Unicode chars >=0x0100 */
static void buildPseudoTables()
/*
The rules for pseudo-Bidi are as follows:
- [ == LRE
- ] == RLE
- { == LRO
- } == RLO
- ^ == PDF
- @ == LRM
- & == RLM
- A-F == Arabic Letters 0631-0636
- G-V == Hebrew letters 05d7-05ea
- W-Z == Unassigned RTL 08d0-08d3
- 0-5 == western digits 0030-0035
- 6-9 == Arabic-Indic digits 0666-0669
- ` == Combining Grave Accent 0300 (NSM)
- ~ == Delete 007f (BN)
- | == Paragraph Separator 2029 (B)
- _ == Info Separator 1 001f (S)
All other characters represent themselves as Latin-1, with the corresponding
Bidi properties.
*/
{
int i;
char uchar;
char c;
/* initialize all tables to unknown */
pseudoToUChar = new char[TABLE_SIZE];
UCharToPseudo = new char[TABLE_SIZE];
UCharToPseud2 = new char[TABLE_SIZE];
for (i = 0; i < TABLE_SIZE; i++) {
pseudoToUChar[i] = 0xFFFD;
UCharToPseudo[i] = '?';
UCharToPseud2[i] = '?';
}
/* initialize non letters or digits */
pseudoToUChar[ 0 ] = 0x0000; UCharToPseudo[0x00] = 0 ;
pseudoToUChar[' '] = 0x0020; UCharToPseudo[0x20] = ' ';
pseudoToUChar['!'] = 0x0021; UCharToPseudo[0x21] = '!';
pseudoToUChar['"'] = 0x0022; UCharToPseudo[0x22] = '"';
pseudoToUChar['#'] = 0x0023; UCharToPseudo[0x23] = '#';
pseudoToUChar['$'] = 0x0024; UCharToPseudo[0x24] = '$';
pseudoToUChar['%'] = 0x0025; UCharToPseudo[0x25] = '%';
pseudoToUChar['\'']= 0x0027; UCharToPseudo[0x27] = '\'';
pseudoToUChar['('] = 0x0028; UCharToPseudo[0x28] = '(';
pseudoToUChar[')'] = 0x0029; UCharToPseudo[0x29] = ')';
pseudoToUChar['*'] = 0x002A; UCharToPseudo[0x2A] = '*';
pseudoToUChar['+'] = 0x002B; UCharToPseudo[0x2B] = '+';
pseudoToUChar[','] = 0x002C; UCharToPseudo[0x2C] = ',';
pseudoToUChar['-'] = 0x002D; UCharToPseudo[0x2D] = '-';
pseudoToUChar['.'] = 0x002E; UCharToPseudo[0x2E] = '.';
pseudoToUChar['/'] = 0x002F; UCharToPseudo[0x2F] = '/';
pseudoToUChar[':'] = 0x003A; UCharToPseudo[0x3A] = ':';
pseudoToUChar[';'] = 0x003B; UCharToPseudo[0x3B] = ';';
pseudoToUChar['<'] = 0x003C; UCharToPseudo[0x3C] = '<';
pseudoToUChar['='] = 0x003D; UCharToPseudo[0x3D] = '=';
pseudoToUChar['>'] = 0x003E; UCharToPseudo[0x3E] = '>';
pseudoToUChar['?'] = 0x003F; UCharToPseudo[0x3F] = '?';
pseudoToUChar['\\']= 0x005C; UCharToPseudo[0x5C] = '\\';
/* initialize specially used characters */
pseudoToUChar['`'] = 0x0300; UCharToPseud2[0x00] = '`'; /* NSM */
pseudoToUChar['@'] = 0x200E; UCharToPseud2[0x0E] = '@'; /* LRM */
pseudoToUChar['&'] = 0x200F; UCharToPseud2[0x0F] = '&'; /* RLM */
pseudoToUChar['_'] = 0x001F; UCharToPseudo[0x1F] = '_'; /* S */
pseudoToUChar['|'] = 0x2029; UCharToPseud2[0x29] = '|'; /* B */
pseudoToUChar['['] = 0x202A; UCharToPseud2[0x2A] = '['; /* LRE */
pseudoToUChar[']'] = 0x202B; UCharToPseud2[0x2B] = ']'; /* RLE */
pseudoToUChar['^'] = 0x202C; UCharToPseud2[0x2C] = '^'; /* PDF */
pseudoToUChar['{'] = 0x202D; UCharToPseud2[0x2D] = '{'; /* LRO */
pseudoToUChar['}'] = 0x202E; UCharToPseud2[0x2E] = '}'; /* RLO */
pseudoToUChar['~'] = 0x007F; UCharToPseudo[0x7F] = '~'; /* BN */
/* initialize western digits */
for (i = 0, uchar = 0x0030; i < 6; i++, uchar++) {
c = columns[i];
pseudoToUChar[c] = uchar;
UCharToPseudo[uchar & 0x00ff] = c;
}
/* initialize Hindi digits */
for (i = 6, uchar = 0x0666; i < 10; i++, uchar++) {
c = columns[i];
pseudoToUChar[c] = uchar;
UCharToPseud2[uchar & 0x00ff] = c;
}
/* initialize Arabic letters */
for (i = 10, uchar = 0x0631; i < 16; i++, uchar++) {
c = columns[i];
pseudoToUChar[c] = uchar;
UCharToPseud2[uchar & 0x00ff] = c;
}
/* initialize Hebrew letters */
for (i = 16, uchar = 0x05D7; i < 32; i++, uchar++) {
c = columns[i];
pseudoToUChar[c] = uchar;
UCharToPseud2[uchar & 0x00ff] = c;
}
/* initialize Unassigned code points */
for (i = 32, uchar = 0x08D0; i < 36; i++, uchar++) {
c = columns[i];
pseudoToUChar[c] = uchar;
UCharToPseud2[uchar & 0x00ff] = c;
}
/* initialize Latin lower case letters */
for (i = 36, uchar = 0x0061; i < 62; i++, uchar++) {
c = columns[i];
pseudoToUChar[c] = uchar;
UCharToPseudo[uchar & 0x00ff] = c;
}
tablesInitialized = true;
}
/*----------------------------------------------------------------------*/
static String pseudoToU16(String input)
/* This function converts a pseudo-Bidi string into a char string.
It returns the char string.
*/
{
int len = input.length();
char[] output = new char[len];
int i;
if (!tablesInitialized) {
buildPseudoTables();
}
for (i = 0; i < len; i++)
output[i] = pseudoToUChar[input.charAt(i)];
return new String(output);
}
/*----------------------------------------------------------------------*/
static String u16ToPseudo(String input)
/* This function converts a char string into a pseudo-Bidi string.
It returns the pseudo-Bidi string.
*/
{
int len = input.length();
char[] output = new char[len];
int i;
char uchar;
if (!tablesInitialized) {
buildPseudoTables();
}
for (i = 0; i < len; i++)
{
uchar = input.charAt(i);
output[i] = uchar < 0x0100 ? UCharToPseudo[uchar] :
UCharToPseud2[uchar & 0x00ff];
}
return new String(output);
}
void errcont(String message) {
msg(message, ERR, false, false);
}
void errcontln(String message) {
msg(message, ERR, false, true);
}
void printCaseInfo(Bidi bidi, String src, String dst)
{
int length = bidi.getProcessedLength();
byte[] levels = bidi.getLevels();
char[] levelChars = new char[length];
byte 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: " + new String(levelChars));
errcontln("Source: " + src);
errcontln("Result: " + dst);
errcontln("Direction: " + bidi.getDirection());
errcontln("paraLevel: " + Byte.toString(bidi.getParaLevel()));
errcontln("reorderingMode: " + modeToString(bidi.getReorderingMode()));
errcontln("reorderingOptions: " + spOptionsToString(bidi.getReorderingOptions()));
errcont("Runs: " + runCount + " => logicalStart.length/level: ");
for (int i = 0; i < runCount; i++) {
BidiRun run;
run = bidi.getVisualRun(i);
errcont(" " + run.getStart() + "." + run.getLength() + "/" +
run.getEmbeddingLevel());
}
errcont("\n");
}
static final String mates1 = "<>()[]{}";
static final String mates2 = "><)(][}{";
static final char[] mates1Chars = mates1.toCharArray();
static final char[] mates2Chars = mates2.toCharArray();
boolean matchingPair(Bidi bidi, int i, char c1, char c2)
{
if (c1 == c2) {
return true;
}
/* For REORDER_RUNS_ONLY, it would not be correct to check levels[i],
so we use the appropriate run's level, which is good for all cases.
*/
if (bidi.getLogicalRun(i).getDirection() == 0) {
return false;
}
for (int k = 0; k < mates1Chars.length; k++) {
if ((c1 == mates1Chars[k]) && (c2 == mates2Chars[k])) {
return true;
}
}
return false;
}
boolean checkWhatYouCan(Bidi bidi, String src, String dst)
{
int i, idx, logLimit, visLimit;
boolean testOK, errMap, errDst;
char[] srcChars = src.toCharArray();
char[] dstChars = dst.toCharArray();
int[] visMap = bidi.getVisualMap();
int[] logMap = bidi.getLogicalMap();
testOK = true;
errMap = errDst = false;
logLimit = bidi.getProcessedLength();
visLimit = bidi.getResultLength();
if (visLimit > dstChars.length) {
visLimit = dstChars.length;
}
char[] accumSrc = new char[logLimit];
char[] accumDst = new char[visLimit];
Arrays.fill(accumSrc, '?');
Arrays.fill(accumDst, '?');
if (logMap.length != logLimit) {
errMap = true;
}
for (i = 0; i < logLimit; i++) {
idx = bidi.getVisualIndex(i);
if (idx != logMap[i]) {
errMap = true;
}
if (idx == Bidi.MAP_NOWHERE) {
continue;
}
if (idx >= visLimit) {
continue;
}
accumDst[idx] = srcChars[i];
if (!matchingPair(bidi, i, srcChars[i], dstChars[idx])) {
errDst = true;
}
}
if (errMap) {
if (testOK) {
printCaseInfo(bidi, src, dst);
testOK = false;
}
errln("Mismatch between getLogicalMap() and getVisualIndex()");
errcont("Map :" + valueOf(logMap));
errcont("\n");
errcont("Indexes:");
for (i = 0; i < logLimit; i++) {
errcont(" " + bidi.getVisualIndex(i));
}
errcont("\n");
}
if (errDst) {
if (testOK) {
printCaseInfo(bidi, src, dst);
testOK = false;
}
errln("Source does not map to Result");
errcontln("We got: " + new String(accumDst));
}
errMap = errDst = false;
if (visMap.length != visLimit) {
errMap = true;
}
for (i = 0; i < visLimit; i++) {
idx = bidi.getLogicalIndex(i);
if (idx != visMap[i]) {
errMap = true;
}
if (idx == Bidi.MAP_NOWHERE) {
continue;
}
if (idx >= logLimit) {
continue;
}
accumSrc[idx] = dstChars[i];
if (!matchingPair(bidi, idx, srcChars[idx], dstChars[i])) {
errDst = true;
}
}
if (errMap) {
if (testOK) {
printCaseInfo(bidi, src, dst);
testOK = false;
}
errln("Mismatch between getVisualMap() and getLogicalIndex()");
errcont("Map :" + valueOf(visMap));
errcont("\n");
errcont("Indexes:");
for (i = 0; i < visLimit; i++) {
errcont(" " + bidi.getLogicalIndex(i));
}
errcont("\n");
}
if (errDst) {
if (testOK) {
printCaseInfo(bidi, src, dst);
testOK = false;
}
errln("Result does not map to Source");
errcontln("We got: " + new String(accumSrc));
}
return testOK;
}
}