| /* |
| * 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.text.tests.java.text; |
| |
| import dalvik.annotation.AndroidOnly; |
| import dalvik.annotation.KnownFailure; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargets; |
| |
| import junit.framework.TestCase; |
| |
| import java.text.AttributedString; |
| import java.text.Bidi; |
| import java.util.Arrays; |
| |
| @TestTargetClass(Bidi.class) |
| 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]); |
| } |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify positive case for Bidi(AttributedCharacterIterator paragraph).", |
| method = "Bidi", |
| args = {char[].class, int.class, byte[].class, int.class, int.class, int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify positive case for Bidi(AttributedCharacterIterator paragraph).", |
| method = "Bidi", |
| args = {java.text.AttributedCharacterIterator.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Bidi", |
| args = {String.class, int.class} |
| ) |
| }) |
| 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); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Bidi", |
| args = {char[].class, int.class, byte[].class, int.class, int.class, int.class} |
| ) |
| 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 IllegalArgumentException."); |
| } catch (IllegalArgumentException e) { |
| // expected |
| } |
| |
| bd = new Bidi(new char[] { 'o' }, 0, new byte[] { 2, 2 }, 2, 0, 2); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Bidi", |
| args = {String.class, int.class} |
| ) |
| }) |
| 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()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ) |
| }) |
| 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()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ) |
| }) |
| 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()); |
| } |
| |
| /** |
| * @tests java.text.Bidi#toString() Test of method java.text.Bidi#toString() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "toString", |
| args = {} |
| ) |
| public void testToString() { |
| try { |
| bd = new Bidi("bidi", 173); |
| assertNotNull("Bidi representation is null", bd.toString()); |
| } catch (Exception e) { |
| fail("Unexpected exception " + e.toString()); |
| } |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify that these methods can return all possible flags.", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify that these methods can return all possible flags.", |
| method = "getLength", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify that these methods can return all possible flags.", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify that these methods can return all possible flags.", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify that these methods can return all possible flags.", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify that these methods can return all possible flags.", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify that these methods can return all possible flags.", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify that these methods can return all possible flags.", |
| method = "Bidi", |
| args = {java.lang.String.class, int.class} |
| ) |
| }) |
| 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()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies IllegalArgumentException.", |
| method = "Bidi", |
| args = {char[].class, int.class, byte[].class, int.class, int.class, int.class} |
| ) |
| 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 |
| } |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ) |
| }) |
| 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()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ) |
| }) |
| 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()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ) |
| }) |
| 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()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Bidi", |
| args = {String.class, int.class} |
| ) |
| }) |
| 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()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Bidi", |
| args = {String.class, int.class} |
| ) |
| }) |
| 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()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Bidi", |
| args = {String.class, int.class} |
| ) |
| }) |
| 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. |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Bidi", |
| args = {String.class, int.class} |
| ) |
| }) |
| 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()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Bidi", |
| args = {String.class, int.class} |
| ) |
| }) |
| // 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()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Bidi", |
| args = {String.class, int.class} |
| ) |
| }) |
| 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()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Bidi", |
| args = {char[].class, int.class, byte[].class, int.class, int.class, int.class} |
| ) |
| }) |
| 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()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "requiresBidi", |
| args = {char[].class, int.class, int.class} |
| ) |
| 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)); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Bidi", |
| args = {char[].class, int.class, byte[].class, int.class, int.class, int.class} |
| ) |
| }) |
| 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()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "createLineBidi", |
| args = {int.class, int.class} |
| ) |
| }) |
| public void testCreateLineBidi() { |
| bd = new Bidi("a\u05D0a\na\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(1, line.getLevelAt(1)); |
| assertEquals(3, line.getLevelAt(2)); |
| assertEquals(3, line.getLevelAt(3)); |
| assertEquals(2, line.getLevelAt(4)); |
| assertEquals(1, line.getLevelAt(1000)); |
| assertEquals(4, line.getRunCount()); |
| assertRunArrayEquals(new int[][] { { 0, 1, 2 }, { 1, 2, 1 }, |
| { 2, 4, 3 }, { 4, 5, 2 }, }, line); |
| assertFalse(line.isLeftToRight()); |
| assertTrue(line.isMixed()); |
| assertFalse(line.isRightToLeft()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies IllegalArgumentException.", |
| method = "createLineBidi", |
| args = {int.class, int.class} |
| ) |
| public void testCreateLineBidiInvalid() { |
| // regression for HARMONY-1050 |
| Bidi bidi = new Bidi("str", Bidi.DIRECTION_RIGHT_TO_LEFT); |
| 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 |
| } |
| |
| // Outsourced to _AndroidFailure: |
| // bidi.createLineBidi(2, 2); |
| |
| try { |
| bidi.createLineBidi(2, 4); |
| fail("Expected IAE"); |
| } catch (IllegalArgumentException e) { |
| // Expected |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| method = "createLineBidi", |
| args = {int.class, int.class} |
| ) |
| @KnownFailure("Is this a failure or just a different behaviour of ICU?") |
| public void testCreateLineBidi_AndroidFailure() { |
| Bidi bidi = new Bidi("str", Bidi.DIRECTION_RIGHT_TO_LEFT); |
| bidi.createLineBidi(2, 2); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "baseIsLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLevelAt", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getRunCount", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isRightToLeft", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLeftToRight", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isMixed", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getBaseLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getLength", |
| args = {} |
| ) |
| }) |
| @AndroidOnly("ICU treats new lines different from RI.") |
| 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()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "reorderVisually", |
| args = {byte[].class, int.class, java.lang.Object[].class, int.class, int.class} |
| ) |
| 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()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies exceptions.", |
| method = "reorderVisually", |
| args = {byte[].class, int.class, java.lang.Object[].class, int.class, int.class} |
| ) |
| 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 |
| } |
| |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Regression test.", |
| method = "getRunLimit", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Regression test.", |
| method = "getRunStart", |
| args = {int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Regression test.", |
| method = "getRunCount", |
| args = {} |
| ) |
| }) |
| 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)); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify any int value between 0 and getRunCount().", |
| method = "getRunLimit", |
| args = {int.class} |
| ) |
| public void testGetRunLimit() { |
| bd = new Bidi("text", Bidi.DIRECTION_LEFT_TO_RIGHT); |
| try { |
| assertTrue(4 == bd.getRunLimit(-1)); |
| } catch (Exception e) { |
| fail("Unexpected exception: " + e); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getRunLevel", |
| args = {int.class} |
| ) |
| public void testGetRunLevelLInt() { |
| bd = new Bidi("text", Bidi.DIRECTION_LEFT_TO_RIGHT); |
| try { |
| assertEquals(0, bd.getRunLevel(0)); |
| assertEquals(0, bd.getRunLevel(bd.getRunCount())); |
| } catch (Exception e) { |
| fail("Unexpected exception: " + e); |
| } |
| |
| bd = new Bidi("text", Bidi.DIRECTION_RIGHT_TO_LEFT); |
| try { |
| assertEquals(2, bd.getRunLevel(0)); |
| } catch (Exception e) { |
| fail("Unexpected exception: " + e); |
| } |
| |
| bd = new Bidi("text", Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT); |
| try { |
| assertEquals(0, bd.getRunLevel(0)); |
| } catch (Exception e) { |
| fail("Unexpected exception: " + e); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "getRunStart", |
| args = {int.class} |
| ) |
| public void testGetRunStart() { |
| 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); |
| assertEquals(0, bd.getRunStart(0)); |
| assertEquals(1, bd.getRunStart(1)); |
| assertEquals(2, bd.getRunStart(2)); |
| |
| 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)); |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Bidi", |
| args = {java.text.AttributedCharacterIterator.class} |
| ) |
| public void testBidiConstructor_Iterator() { |
| AttributedString paragraph = new AttributedString("text"); |
| bd = new Bidi(paragraph.getIterator()); |
| try { |
| assertTrue(4 == bd.getRunLimit(1)); |
| } catch (Exception e) { |
| fail("Unexpected exception: " + e); |
| } |
| } |
| } |
