/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.harmony.tests.java.text;

import java.text.AttributedString;
import java.text.Bidi;
import java.util.Arrays;

import junit.framework.TestCase;

public class BidiTest extends TestCase {

	Bidi bd;

	public static void assertRunArrayEquals(int[][] expected, Bidi bidi) {
		assertEquals("different length", expected.length, bidi.getRunCount());

		FORRUN: for (int i = 0; i < bidi.getRunCount(); i++) {
			int[] butWas = new int[] { bidi.getRunStart(i),
					bidi.getRunLimit(i), bidi.getRunLevel(i) };

			for (int j = 0; j < expected.length; j++) {
				if (expected[j][0] == butWas[0] && expected[j][1] == butWas[1]
						&& expected[j][2] == butWas[2]) {
					continue FORRUN;
				}
			}
			fail("expected [" + i + "] " + " start: " + butWas[0] + " limit: "
					+ butWas[1] + " level: " + butWas[2]);
		}
	}

	public void testNullPointerConstructor() {
		try {
			bd = new Bidi(null, Bidi.DIRECTION_RIGHT_TO_LEFT);
			fail("should throw IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

		try {
			bd = new Bidi(null, 0, new byte[] { 0 }, 0, 0,
					Bidi.DIRECTION_RIGHT_TO_LEFT);
			fail("should throw IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

		try {
            bd = new Bidi(null);
            fail("should throw IAE");
        } catch (IllegalArgumentException e) {
        }

		bd = new Bidi("a".toCharArray(), 0, null, 0, 1,
				Bidi.DIRECTION_RIGHT_TO_LEFT);
	}

	public void testBadLength() {
		try {
			bd = new Bidi("1".toCharArray(), 0, new byte[] { 0 }, 0, 20,
					Bidi.DIRECTION_RIGHT_TO_LEFT);
			fail("should throw IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

		try {
			bd = new Bidi("1234567".toCharArray(), 0, new byte[] { 0 }, 0, 4,
					Bidi.DIRECTION_RIGHT_TO_LEFT);
			fail("should throw IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

		try {
			bd = new Bidi("1234567".toCharArray(), 4, new byte[] { 0, 1, 2, 3,
					4 }, 0, 5, Bidi.DIRECTION_RIGHT_TO_LEFT);
			fail("should throw IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

		try {
			bd = new Bidi("1234567".toCharArray(), 0, new byte[] { 0, 1, 2, 3,
					4 }, 4, 5, Bidi.DIRECTION_RIGHT_TO_LEFT);
			fail("should throw IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

        //regression for HARMONY-1031
		try {
			bd = new Bidi(new char[] { 't','t','t'}, -1, new byte[] { 2, 2 }, 1, 1, 1);
			fail("should be IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

		try {
			bd = new Bidi(new char[] { 't','t','t'}, 1, new byte[] { 2, 2 }, -1, 1, 1);
			fail("should be IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

		try {
			bd = new Bidi(new char[] { 't','t','t'}, 1, new byte[] { 2, 2 }, 1, -1, 1);
			fail("should be IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

		try {
			bd = new Bidi(new char[] {}, 5, new byte[] { 2, 2, 2, 2, 2, 2 }, 8, Integer.MAX_VALUE, 5);
			fail("should be IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

        try {
            bd = new Bidi(null, 5, null, 8, Integer.MAX_VALUE, 5);
            fail("should be IAE");
        } catch (IllegalArgumentException e) {
            // expected
        }

		bd = new Bidi(new char[] {'o'}, 0, new byte[] { 2, 2}, 2, 0, 2 );
	}

	public void testEmptyParagraph() {
		bd = new Bidi("", Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(0, bd.getLength());
		assertEquals(0, bd.getLevelAt(0));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 0, 0 } }, bd);
		assertTrue(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi("", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(0, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 0, 1 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertTrue(bd.isRightToLeft());

		bd = new Bidi("", Bidi.DIRECTION_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(0, bd.getLength());
		assertEquals(0, bd.getLevelAt(0));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 0, 0 }, }, bd);
		assertTrue(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi("", Bidi.DIRECTION_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(0, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 0, 1 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertTrue(bd.isRightToLeft());
	}

	public void testSpaceParagraph() {
		bd = new Bidi(" ", Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(1, bd.getLength());
		assertEquals(0, bd.getLevelAt(0));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 0 }, }, bd);
		assertTrue(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi(" ", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(1, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertTrue(bd.isRightToLeft());

		bd = new Bidi(" ", Bidi.DIRECTION_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(1, bd.getLength());
		assertEquals(0, bd.getLevelAt(0));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 0 }, }, bd);
		assertTrue(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi(" ", Bidi.DIRECTION_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(1, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertTrue(bd.isRightToLeft());
	}

	public void testSimpleParagraph() {
		bd = new Bidi("t", Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(1, bd.getLength());
		assertEquals(0, bd.getLevelAt(0));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 0 }, }, bd);
		assertTrue(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi("t", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(1, bd.getLength());
		assertEquals(0, bd.getLevelAt(0));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 0 }, }, bd);
		assertTrue(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi("t", Bidi.DIRECTION_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(1, bd.getLength());
		assertEquals(0, bd.getLevelAt(0));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 0 }, }, bd);
		assertTrue(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertFalse(bd.isRightToLeft());
	}

	public void testBadFlags() {
		bd = new Bidi("", 173);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(0, bd.getLength());
		assertEquals(0, bd.getLevelAt(0));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 0, 0 }, }, bd);
		assertTrue(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertFalse(bd.isRightToLeft());
	}

	public void testBadEmbeddings() {
		try {
			bd = new Bidi("".toCharArray(), 0, new byte[] {}, 0, 1,
					Bidi.DIRECTION_RIGHT_TO_LEFT);
			fail("should throw IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}
	}

	public void testOverrideEmbeddings() {
		bd = new Bidi(new char[] { 's', 's', 's' }, 0, new byte[] { (byte) -7,
				(byte) -2, (byte) -3 }, 0, 3,
				Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(3, bd.getLength());
		assertEquals(7, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(3, bd.getLevelAt(2));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(3, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 7 }, { 1, 2, 2 },
				{ 2, 3, 3 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi(new char[] { 's', 's', 's' }, 0, new byte[] { (byte) -1,
				(byte) -2, (byte) -3 }, 0, 3,
				Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(3, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(3, bd.getLevelAt(2));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(3, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 },
				{ 2, 3, 3 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi(new char[] { 's', 's', 's' }, 0, new byte[] { (byte) -1,
				(byte) -2, (byte) -3 }, 0, 3, Bidi.DIRECTION_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(3, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(3, bd.getLevelAt(2));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(3, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 },
				{ 2, 3, 3 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi(new char[] { 's', 's', 's' }, 0, new byte[] { (byte) -1,
				(byte) -2, (byte) -3 }, 0, 3, Bidi.DIRECTION_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(3, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(3, bd.getLevelAt(2));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(3, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 },
				{ 2, 3, 3 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());
	}

	public void testDefaultEmbeddings() {
		bd = new Bidi(new char[] { 's', 's', 's' }, 0, new byte[] { (byte) 0,
				(byte) 0, (byte) 0 }, 0, 3, Bidi.DIRECTION_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(3, bd.getLength());
		assertEquals(2, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(2, bd.getLevelAt(2));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 3, 2 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());
	}

	public void testRelativeEmbeddings() {
		bd = new Bidi(new char[] { 's', 's', 's' }, 0, new byte[] { (byte) 1,
				(byte) 2, (byte) 3 }, 0, 3, Bidi.DIRECTION_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(3, bd.getLength());
		assertEquals(2, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(4, bd.getLevelAt(2));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(2, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 2, 2 }, { 2, 3, 4 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());
	}

	public void testSimpleHebrewParagraph() {
		bd = new Bidi("\u05D0", Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(1, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertTrue(bd.isRightToLeft());

		bd = new Bidi("\u05D0", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(1, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertTrue(bd.isRightToLeft());

		bd = new Bidi("\u05D0", Bidi.DIRECTION_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(1, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertFalse(bd.isMixed());
		assertTrue(bd.isRightToLeft());
	}

	public void testSimpleBidiParagraph_1() {
		bd = new Bidi("\u05D0a", Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(2, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(2, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi("\u05D0a", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(2, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(2, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi("\u05D0a", Bidi.DIRECTION_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(2, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(0, bd.getLevelAt(1));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(2, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 0 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi("\u05D0a", Bidi.DIRECTION_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(2, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(2, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());
	}

	public void testSimpleBidiParagraph_2() {
		bd = new Bidi("a\u05D0", Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(2, bd.getLength());
		assertEquals(0, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(2, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 0 }, { 1, 2, 1 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi("a\u05D0", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(2, bd.getLength());
		assertEquals(0, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(2, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 0 }, { 1, 2, 1 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi("a\u05D0", Bidi.DIRECTION_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(2, bd.getLength());
		assertEquals(0, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(2, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 0 }, { 1, 2, 1 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi("a\u05D0", Bidi.DIRECTION_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(2, bd.getLength());
		assertEquals(2, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(2, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 2 }, { 1, 2, 1 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());
	}

	/*
	 * spec reads: public static final int DIRECTION_RIGHT_TO_LEFT Constant
	 * indicating base direction is right-to-left. according to that, the method
	 * baseIsLeftToRight() here should return false. however, RI doesn't act so.
	 */
	public void testRIBug_1() {
		bd = new Bidi("t", Bidi.DIRECTION_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		// the base level it the essential cause
		assertEquals(1, bd.getBaseLevel());
		assertEquals(1, bd.getLength());
		assertEquals(2, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 2 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());
	}

	// this is essentially the same bug as Bug_1
	public void testRIBug_2() {
		bd = new Bidi("\u05D0", Bidi.DIRECTION_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(1, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(1, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());
	}

	public void testComplicatedBidi() {
		bd = new Bidi("a\u05D0a\"a\u05D0\"\u05D0a",
				Bidi.DIRECTION_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(9, bd.getLength());
		assertEquals(2, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1));
		assertEquals(2, bd.getLevelAt(2));
		assertEquals(2, bd.getLevelAt(3));
		assertEquals(2, bd.getLevelAt(4));
		assertEquals(1, bd.getLevelAt(5));
		assertEquals(1, bd.getLevelAt(6));
		assertEquals(1, bd.getLevelAt(7));
		assertEquals(2, bd.getLevelAt(8));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(5, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 2 }, { 1, 2, 1 },
				{ 2, 5, 2 }, { 5, 8, 1 }, { 8, 9, 2 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());
	}

	public void testComplicatedOverrideBidi() {
		bd = new Bidi("a\u05D0a\"a\u05D0\"\u05D0a".toCharArray(), 0,
				new byte[] { 0, 0, 0, -3, -3, 2, 2, 0, 3 }, 0, 9,
				Bidi.DIRECTION_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(9, bd.getLength());
		assertEquals(2, bd.getLevelAt(0));
		assertEquals(1, bd.getLevelAt(1));
		assertEquals(2, bd.getLevelAt(2));
		assertEquals(3, bd.getLevelAt(3));
		assertEquals(3, bd.getLevelAt(4));
		assertEquals(3, bd.getLevelAt(5));
		assertEquals(2, bd.getLevelAt(6));
		assertEquals(1, bd.getLevelAt(7));
		assertEquals(4, bd.getLevelAt(8));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(7, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 2 }, { 1, 2, 1 },
				{ 2, 3, 2 }, { 3, 6, 3 }, { 6, 7, 2 }, { 7, 8, 1 },
				{ 8, 9, 4 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());
	}

	public void testRequiresBidi() {
		try{
		    Bidi.requiresBidi(null, 0, 0);
		    fail("should throw NullPointerException");
        }catch (NullPointerException e){
            // expected
        }

		try {
			assertFalse(Bidi.requiresBidi(null, 0, 1));
			fail("should throw NPE");
		} catch (NullPointerException e) {
			// expected
		}
		try {
			assertFalse(Bidi.requiresBidi("".toCharArray(), 0, 1));
			fail("should throw IllegalArgumentException");
		} catch (IllegalArgumentException e) {
			// expected
		}
		try {
			assertFalse(Bidi.requiresBidi("aaa".toCharArray(), -1, 1));
			fail("should throw IllegalArgumentException");
		} catch (IllegalArgumentException e) {
			// expected
		}
        try {
            assertFalse(Bidi.requiresBidi("aaa".toCharArray(), 1, -1));
            fail("should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // expected
        }
        try {
            assertFalse(Bidi.requiresBidi("\u05D0".toCharArray(), 1, -1));
            fail("should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // expected
        }
        try {
            assertFalse(Bidi.requiresBidi("aaa".toCharArray(), 1, 0));
            fail("should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // expected
        }
        try {
            assertFalse(Bidi.requiresBidi("aaa".toCharArray(), 7, 7));
            fail("should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // expected
        }
        try {
            assertFalse(Bidi.requiresBidi("aaa".toCharArray(), 1, Integer.MAX_VALUE));
            fail("should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // expected
        }
        try {
            assertFalse(Bidi.requiresBidi("aaa".toCharArray(), Integer.MAX_VALUE, 1));
            fail("should throw IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            // expected
        }

        assertFalse(Bidi.requiresBidi("".toCharArray(), 0, 0));
        assertFalse(Bidi.requiresBidi("aaa".toCharArray(), 1, 1));
        assertFalse(Bidi.requiresBidi("aaa".toCharArray(), 0, 2));
		assertFalse(Bidi.requiresBidi("\u05D0".toCharArray(), 1, 1));
		assertTrue(Bidi.requiresBidi("\u05D0".toCharArray(), 0, 1));
		assertFalse(Bidi.requiresBidi("aa\u05D0a".toCharArray(), 0, 2));
		assertTrue(Bidi.requiresBidi("aa\u05D0a".toCharArray(), 1, 3));
	}

	public void testHebrewOverrideEmbeddings() {
		bd = new Bidi(new char[] { '\u05D0', '\u05D0', '\u05D0' }, 0,
				new byte[] { (byte) -1, (byte) -2, (byte) -3 }, 0, 3,
				Bidi.DIRECTION_DEFAULT_LEFT_TO_RIGHT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(3, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(3, bd.getLevelAt(2));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(3, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 },
				{ 2, 3, 3 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi(new char[] { '\u05D0', '\u05D0', '\u05D0' }, 0,
				new byte[] { (byte) -1, (byte) -2, (byte) -3 }, 0, 3,
				Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(3, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(3, bd.getLevelAt(2));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(3, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 },
				{ 2, 3, 3 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi(new char[] { '\u05D0', '\u05D0', '\u05D0' }, 0,
				new byte[] { (byte) -1, (byte) -2, (byte) -3 }, 0, 3,
				Bidi.DIRECTION_LEFT_TO_RIGHT);
		assertTrue(bd.baseIsLeftToRight());
		assertEquals(0, bd.getBaseLevel());
		assertEquals(3, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(3, bd.getLevelAt(2));
		assertEquals(0, bd.getLevelAt(1000));
		assertEquals(3, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 },
				{ 2, 3, 3 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());

		bd = new Bidi(new char[] { '\u05D0', '\u05D0', '\u05D0' }, 0,
				new byte[] { (byte) -1, (byte) -2, (byte) -3 }, 0, 3,
				Bidi.DIRECTION_RIGHT_TO_LEFT);
		assertFalse(bd.baseIsLeftToRight());
		assertEquals(1, bd.getBaseLevel());
		assertEquals(3, bd.getLength());
		assertEquals(1, bd.getLevelAt(0));
		assertEquals(2, bd.getLevelAt(1));
		assertEquals(3, bd.getLevelAt(2));
		assertEquals(1, bd.getLevelAt(1000));
		assertEquals(3, bd.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 1 }, { 1, 2, 2 },
				{ 2, 3, 3 }, }, bd);
		assertFalse(bd.isLeftToRight());
		assertTrue(bd.isMixed());
		assertFalse(bd.isRightToLeft());
	}

	public void testCreateLineBidi() {
		bd = new Bidi("a\u05D0a\u05D0a\u05D0\"\u05D0a".toCharArray(), 0,
				new byte[] { 0, 0, 0, -3, -3, 2, 2, 0, 3 }, 0, 9,
				Bidi.DIRECTION_RIGHT_TO_LEFT);
		Bidi line = bd.createLineBidi(2, 7);
		assertFalse(line.baseIsLeftToRight());
		assertEquals(1, line.getBaseLevel());
		assertEquals(5, line.getLength());
		assertEquals(2, line.getLevelAt(0));
		assertEquals(3, line.getLevelAt(1));
		assertEquals(3, line.getLevelAt(2));
		assertEquals(3, line.getLevelAt(3));
		assertEquals(2, line.getLevelAt(4));
		assertEquals(1, line.getLevelAt(1000));
		assertEquals(3, line.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 1, 2 }, { 1, 4, 3 },
				{ 4, 5, 2 }, }, line);
		assertFalse(line.isLeftToRight());
		assertTrue(line.isMixed());
		assertFalse(line.isRightToLeft());
	}

    public void testCreateLineBidiInvalid() {
        //regression for HARMONY-1050
        Bidi bidi = new Bidi("str", 1);
        try {
            bidi.createLineBidi(-1, 1);
            fail("Expected IAE");
        } catch (IllegalArgumentException e) {
            // Expected
        }

        try {
            bidi.createLineBidi(1, -1);
            fail("Expected IAE");
        } catch (IllegalArgumentException e) {
            // Expected
        }

        try {
            bidi.createLineBidi(-1, -1);
            fail("Expected IAE");
        } catch (IllegalArgumentException e) {
            // Expected
        }

        try {
            bidi.createLineBidi(2, 1);
            fail("Expected IAE");
        } catch (IllegalArgumentException e) {
            // Expected
        }

        try {
            bidi.createLineBidi(2, 2);
        }catch (IllegalArgumentException e){
            // Expected
        }

        try {
            bidi.createLineBidi(2, 4);
            fail("Expected IAE");
        } catch (IllegalArgumentException e) {
            // Expected
        }
    }

	public void testIncompatibleLineAlgorithm() {
		// ICU treat a new line as in the same run, however RI does not
		bd = new Bidi("aaaaa".toCharArray(), 0,
				new byte[] { -2, -1, -3, -3, -2 }, 0, 5,
				Bidi.DIRECTION_RIGHT_TO_LEFT);
		Bidi line = bd.createLineBidi(1, 4);
		assertFalse(line.baseIsLeftToRight());
		assertEquals(1, line.getBaseLevel());
		assertEquals(3, line.getLength());
		assertEquals(1, line.getLevelAt(0));
		assertEquals(1, line.getLevelAt(1));
		assertEquals(1, line.getLevelAt(2));
		assertEquals(1, line.getLevelAt(1000));
		assertEquals(1, line.getRunCount());
		assertRunArrayEquals(new int[][] { { 0, 3, 1 }, }, line);
		assertFalse(line.isLeftToRight());
		assertFalse(line.isMixed());
		assertTrue(line.isRightToLeft());
	}

	public void testReorderVisually() {
		String[] init = new String[] { "a", "b", "c", "d" };
		String[] s = new String[4];

		System.arraycopy(init, 0, s, 0, s.length);
		Bidi.reorderVisually(new byte[] { 2, 1, 3, 0 }, 0, s, 0, 4);
		assertEquals("[c, b, a, d]", Arrays.asList(s).toString());

		System.arraycopy(init, 0, s, 0, s.length);
		Bidi.reorderVisually(new byte[] { 1, 3 }, 0, s, 1, 2);
		assertEquals("[a, c, b, d]", Arrays.asList(s).toString());

		System.arraycopy(init, 0, s, 0, s.length);
		Bidi.reorderVisually(new byte[] { 2, 1, 3, 0 }, 1, s, 1, 2);
		assertEquals("[a, c, b, d]", Arrays.asList(s).toString());

		System.arraycopy(init, 0, s, 0, s.length);
		Bidi.reorderVisually(new byte[] { 2, 1, 2, 1 }, 1, s, 0, 3);
		assertEquals("[c, b, a, d]", Arrays.asList(s).toString());

		System.arraycopy(init, 0, s, 0, s.length);
		Bidi.reorderVisually(new byte[] { 2, 1, 0, 1 }, 1, s, 0, 3);
		assertEquals("[a, b, c, d]", Arrays.asList(s).toString());
	}

	public void testBadReorderVisually() {
		String[] s = new String[] { "a", "b", "c", "d" };

		try {
			Bidi.reorderVisually(new byte[] { 2, 1, 3, 0 }, 0, s, 0, 5);
			fail("should throw IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

		try {
			Bidi.reorderVisually(new byte[] { 2, 1, 3, 0 }, 0, s, -1, 1);
			fail("should throw IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

		try {
			Bidi.reorderVisually(new byte[] { 2, 1, 3, 0 }, -1, s, 0, 1);
			fail("should throw IAE");
		} catch (IllegalArgumentException e) {
			// expected
		}

		try {
			Bidi.reorderVisually(null, 0, s, 0, 1);
			fail("should throw NPE");
		} catch (NullPointerException e) {
			// expected
		}

		try {
			Bidi.reorderVisually(new byte[] { 2, 1, 3, 0 }, 0, null, 0, 1);
			fail("should throw NPE");
		} catch (NullPointerException e) {
			// expected
		}

        try {
            Bidi.reorderVisually(new byte[] { 2, 1, 3, 0 }, 1, s, 0, -1);
            fail("should throw IAE");
        } catch (IllegalArgumentException e) {
            // expected
        }

	}

    public void testGetRuns() {
        //Regression test for Harmony-1028

        String LTR = "\u0061\u0062";
        String RTL = "\u05DC\u05DD";
        String newLine = "\n";
        String defText = LTR + newLine + RTL + LTR + RTL;

        int[][] expectedRuns = {
                {0, 3},
                {3, 5},
                {5, 7},
                {7, 9},
        };

        Bidi bi = new Bidi(defText, 0);
        final int count = bi.getRunCount();
        for (int i = 0; i < count; i++) {
            assertEquals(expectedRuns[i][0], bi.getRunStart(i));
            assertEquals(expectedRuns[i][1], bi.getRunLimit(i));
        }
    }
}