--- /dev/null
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed 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 android.text.cts;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.Rect;
+import android.graphics.Bitmap.Config;
+import android.test.AndroidTestCase;
+import android.text.Layout;
+import android.text.Spannable;
+import android.text.SpannableString;
+import android.text.TextPaint;
+import android.text.Layout.Alignment;
+import android.text.style.StrikethroughSpan;
+
+import dalvik.annotation.BrokenTest;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.ToBeFixed;
+
+@TestTargetClass(Layout.class)
+public class LayoutTest extends AndroidTestCase {
+ private final static int LINE_COUNT = 5;
+ private final static int LINE_HEIGHT = 12;
+ private final static int LINE_DESCENT = 4;
+ private final static CharSequence LAYOUT_TEXT = "alwei\t;sdfs\ndf @";
+
+ private int mWidth;
+ private Layout.Alignment mAlign;
+ private float mSpacingmult;
+ private float mSpacingadd;
+ private SpannableString mSpannedText;
+
+ private TextPaint mTextPaint;
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ mTextPaint = new TextPaint();
+ mSpannedText = new SpannableString(LAYOUT_TEXT);
+ mSpannedText.setSpan(new StrikethroughSpan(), 0, 1, Spannable.SPAN_INCLUSIVE_EXCLUSIVE);
+ mWidth = 11;
+ mAlign = Alignment.ALIGN_CENTER;
+ mSpacingmult = 1;
+ mSpacingadd = 2;
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "Layout",
+ args = {java.lang.CharSequence.class, android.text.TextPaint.class, int.class,
+ android.text.Layout.Alignment.class, float.class, float.class}
+ )
+ @ToBeFixed(bug = "1417734", explanation = "should add @throws clause into javadoc " +
+ " of Layout constructor when the width is smaller than 0")
+ public void testConstructor() {
+ new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth, mAlign, mSpacingmult, mSpacingadd);
+
+ try {
+ new MockLayout(null, null, -1, null, 0, 0);
+ fail("should throw IllegalArgumentException here");
+ } catch (IllegalArgumentException e) {
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "draw",
+ args = {android.graphics.Canvas.class}
+ )
+ @ToBeFixed(bug = "1386429", explanation = "can not get the" +
+ " package protected class Directions")
+ public void testDraw1() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ layout.draw(new Canvas());
+
+ try {
+ layout.draw(new Canvas(Bitmap.createBitmap(200, 200, Config.ARGB_4444)));
+ fail("should throw NullPointerException here");
+ } catch (NullPointerException e) {
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "draw",
+ args = {android.graphics.Canvas.class, android.graphics.Path.class,
+ android.graphics.Paint.class, int.class}
+ )
+ @ToBeFixed(bug = "1386429", explanation = "can not get the" +
+ " package protected class Directions")
+ public void testDraw2() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ layout.draw(new Canvas(), null, null, 0);
+
+ try {
+ Bitmap bitmap = Bitmap.createBitmap(200, 200,Config.ARGB_4444);
+ layout.draw(new Canvas(bitmap), null, null, 0);
+ fail("should throw NullPointerException here");
+ } catch (NullPointerException e) {
+ }
+
+ try {
+ Bitmap bitmap = Bitmap.createBitmap(200, 200, null);
+ layout.draw(new Canvas(bitmap), new Path(), new Paint(), 2);
+ fail("should throw NullPointerException here");
+ } catch (NullPointerException e) {
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getText",
+ args = {}
+ )
+ public void testGetText() {
+ CharSequence text = "test case 1";
+ Layout layout = new MockLayout(text, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(text, layout.getText());
+
+ layout = new MockLayout(null, mTextPaint, mWidth, mAlign, mSpacingmult, mSpacingadd);
+ assertNull(layout.getText());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getPaint",
+ args = {}
+ )
+ public void testGetPaint() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+
+ assertSame(mTextPaint, layout.getPaint());
+
+ layout = new MockLayout(LAYOUT_TEXT, null, mWidth, mAlign, mSpacingmult, mSpacingadd);
+ assertNull(layout.getPaint());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getWidth",
+ args = {}
+ )
+ public void testGetWidth() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, 10,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(10, layout.getWidth());
+
+ layout = new MockLayout(LAYOUT_TEXT, mTextPaint, 0, mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(0, layout.getWidth());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getEllipsizedWidth",
+ args = {}
+ )
+ public void testGetEllipsizedWidth() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, 15,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(15, layout.getEllipsizedWidth());
+
+ layout = new MockLayout(LAYOUT_TEXT, mTextPaint, 0, mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(0, layout.getEllipsizedWidth());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "increaseWidthTo",
+ args = {int.class}
+ )
+ @ToBeFixed(bug = "1417734", explanation = "should add @throws clause into javadoc " +
+ " of Layout#increaseWidthTo(int) when the new width is smaller than old one")
+ public void testIncreaseWidthTo() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ int oldWidth = layout.getWidth();
+
+ layout.increaseWidthTo(oldWidth);
+ assertEquals(oldWidth, layout.getWidth());
+
+ try {
+ layout.increaseWidthTo(oldWidth - 1);
+ fail("should throw runtime exception attempted to reduce Layout width");
+ } catch (RuntimeException e) {
+ }
+
+ layout.increaseWidthTo(oldWidth + 1);
+ assertEquals(oldWidth + 1, layout.getWidth());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getHeight",
+ args = {}
+ )
+ public void testGetHeight() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(60, layout.getHeight());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getAlignment",
+ args = {}
+ )
+ public void testGetAlignment() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertSame(mAlign, layout.getAlignment());
+
+ layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth, null, mSpacingmult, mSpacingadd);
+ assertNull(layout.getAlignment());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getSpacingMultiplier",
+ args = {}
+ )
+ public void testGetSpacingMultiplier() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth, mAlign, -1, mSpacingadd);
+ assertEquals(-1.0f, layout.getSpacingMultiplier());
+
+ layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth, mAlign, 5, mSpacingadd);
+ assertEquals(5.0f, layout.getSpacingMultiplier());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getSpacingAdd",
+ args = {}
+ )
+ public void testGetSpacingAdd() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth, mAlign, mSpacingmult, -1);
+ assertEquals(-1.0f, layout.getSpacingAdd());
+
+ layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth, mAlign, mSpacingmult, 20);
+ assertEquals(20.0f, layout.getSpacingAdd());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getLineBounds",
+ args = {int.class, android.graphics.Rect.class}
+ )
+ public void testGetLineBounds() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ Rect bounds = new Rect();
+
+ assertEquals(32, layout.getLineBounds(2, bounds));
+ assertEquals(0, bounds.left);
+ assertEquals(mWidth, bounds.right);
+ assertEquals(24, bounds.top);
+ assertEquals(36, bounds.bottom);
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getPrimaryHorizontal",
+ args = {int.class}
+ )
+ @ToBeFixed(bug = "1386429", explanation = "can not get the" +
+ " package protected class Directions")
+ public void testGetPrimaryHorizontal() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ try {
+ layout.getPrimaryHorizontal(0);
+ fail("should throw NullPointerException here");
+ } catch (NullPointerException e) {
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getSecondaryHorizontal",
+ args = {int.class}
+ )
+ @ToBeFixed(bug = "1386429", explanation = "can not get the" +
+ " package protected class Directions")
+ public void testGetSecondaryHorizontal() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ try {
+ layout.getSecondaryHorizontal(0);
+ fail("should throw NullPointerException here");
+ } catch (NullPointerException e) {
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getLineLeft",
+ args = {int.class}
+ )
+ public void testGetLineLeft() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(2.0f, layout.getLineLeft(0));
+ assertEquals(4.0f, layout.getLineLeft(1));
+ assertEquals(1.0f, layout.getLineLeft(2));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getLineRight",
+ args = {int.class}
+ )
+ public void testGetLineRight() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(9.0f, layout.getLineRight(0));
+ assertEquals(7.0f, layout.getLineRight(1));
+ assertEquals(10.0f, layout.getLineRight(2));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getLineMax",
+ args = {int.class}
+ )
+ @BrokenTest("unsure if asserted widths are correct")
+ public void testGetLineMax() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(6.0f, layout.getLineMax(0));
+ assertEquals(3.0f, layout.getLineMax(1));
+ assertEquals(9.0f, layout.getLineMax(2));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getLineWidth",
+ args = {int.class}
+ )
+ @BrokenTest("unsure if asserted widths are correct")
+ public void testGetLineWidth() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(6.0f, layout.getLineWidth(0));
+ assertEquals(3.0f, layout.getLineWidth(1));
+ assertEquals(9.0f, layout.getLineWidth(2));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getLineForVertical",
+ args = {int.class}
+ )
+ public void testGetLineForVertical() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(0, layout.getLineForVertical(-1));
+ assertEquals(0, layout.getLineForVertical(0));
+ assertEquals(0, layout.getLineForVertical(LINE_COUNT));
+ assertEquals(LINE_COUNT - 1, layout.getLineForVertical(1000));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getLineForOffset",
+ args = {int.class}
+ )
+ public void testGetLineForOffset() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(0, layout.getLineForOffset(-1));
+ assertEquals(1, layout.getLineForOffset(1));
+ assertEquals(LINE_COUNT - 1, layout.getLineForOffset(LINE_COUNT - 1));
+ assertEquals(LINE_COUNT - 1, layout.getLineForOffset(1000));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getOffsetForHorizontal",
+ args = {int.class, float.class}
+ )
+ @ToBeFixed(bug = "1386429", explanation = "can not get the" +
+ " package protected class Directions")
+ public void testGetOffsetForHorizontal() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ try {
+ layout.getOffsetForHorizontal(0, 0);
+ fail("should throw NullPointerException here");
+ } catch (NullPointerException e) {
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getLineEnd",
+ args = {int.class}
+ )
+ public void testGetLineEnd() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(2, layout.getLineEnd(1));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getLineVisibleEnd",
+ args = {int.class}
+ )
+ @ToBeFixed(bug = "1417734", explanation = "should add @throws clause into javadoc " +
+ " of Layout#getLineVisibleEnd(int) when the line is out of bound")
+ public void testGetLineVisibleEnd() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+
+ assertEquals(2, layout.getLineVisibleEnd(1));
+ assertEquals(LINE_COUNT, layout.getLineVisibleEnd(LINE_COUNT - 1));
+ assertEquals(LAYOUT_TEXT.length(), layout.getLineVisibleEnd(LAYOUT_TEXT.length() - 1));
+ try {
+ layout.getLineVisibleEnd(LAYOUT_TEXT.length());
+ fail("should throw .StringIndexOutOfBoundsException here");
+ } catch (StringIndexOutOfBoundsException e) {
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getLineBottom",
+ args = {int.class}
+ )
+ public void testGetLineBottom() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(LINE_HEIGHT, layout.getLineBottom(0));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getLineBaseline",
+ args = {int.class}
+ )
+ public void testGetLineBaseline() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(8, layout.getLineBaseline(0));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getLineAscent",
+ args = {int.class}
+ )
+ public void testGetLineAscent() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(-8, layout.getLineAscent(0));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getOffsetToLeftOf",
+ args = {int.class}
+ )
+ @ToBeFixed(bug = "1386429", explanation = "can not get the" +
+ " package protected class Directions")
+ public void testGetOffsetToLeftOf() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ try {
+ layout.getOffsetToLeftOf(0);
+ fail("should throw NullPointerException here");
+ } catch (NullPointerException e) {
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getOffsetToRightOf",
+ args = {int.class}
+ )
+ @ToBeFixed(bug = "1386429", explanation = "can not get the" +
+ " package protected class Directions")
+ public void testGetOffsetToRightOf() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ try {
+ layout.getOffsetToRightOf(0);
+ fail("should throw NullPointerException here");
+ } catch (NullPointerException e) {
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getCursorPath",
+ args = {int.class, android.graphics.Path.class, java.lang.CharSequence.class}
+ )
+ @ToBeFixed(bug = "1386429", explanation = "can not get the" +
+ " package protected class Directions")
+ public void testGetCursorPath() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ try {
+ layout.getCursorPath(0, new Path(), "test");
+ fail("should throw NullPointerException here");
+ } catch (NullPointerException e) {
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getSelectionPath",
+ args = {int.class, int.class, android.graphics.Path.class}
+ )
+ @ToBeFixed(bug = "1386429", explanation = "can not get the" +
+ " package protected class Directions")
+ public void testGetSelectionPath() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ Path path = new Path();
+
+ layout.getSelectionPath(0, 0, path);
+
+ try {
+ layout.getSelectionPath(1, 0, path);
+ fail("should throw NullPointerException here");
+ } catch (NullPointerException e) {
+ }
+
+ try {
+ layout.getSelectionPath(0, 1, path);
+ fail("should throw NullPointerException here");
+ } catch (NullPointerException e) {
+ }
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getParagraphAlignment",
+ args = {int.class}
+ )
+ public void testGetParagraphAlignment() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertSame(mAlign, layout.getParagraphAlignment(0));
+
+ layout = new MockLayout(mSpannedText, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertSame(mAlign, layout.getParagraphAlignment(0));
+ assertSame(mAlign, layout.getParagraphAlignment(1));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getParagraphLeft",
+ args = {int.class}
+ )
+ public void testGetParagraphLeft() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(0, layout.getParagraphLeft(0));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getParagraphRight",
+ args = {int.class}
+ )
+ public void testGetParagraphRight() {
+ Layout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertEquals(mWidth, layout.getParagraphRight(0));
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "isSpanned",
+ args = {}
+ )
+ public void testIsSpanned() {
+ MockLayout layout = new MockLayout(LAYOUT_TEXT, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ // default is not spanned text
+ assertFalse(layout.mockIsSpanned());
+
+ // try to create a spanned text
+ layout = new MockLayout(mSpannedText, mTextPaint, mWidth,
+ mAlign, mSpacingmult, mSpacingadd);
+ assertTrue(layout.mockIsSpanned());
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getDesiredWidth",
+ args = {java.lang.CharSequence.class, int.class, int.class, android.text.TextPaint.class}
+ )
+ public void testGetDesiredWidthRange() {
+ CharSequence textShort = "test";
+ CharSequence textLonger = "test\ngetDesiredWidth";
+ CharSequence textLongest = "test getDesiredWidth";
+ TextPaint paint = new TextPaint();
+ float widthShort = Layout.getDesiredWidth(textShort, 0, textShort.length(), paint);
+ float widthLonger = Layout.getDesiredWidth(textLonger, 0, textLonger.length(), paint);
+ float widthLongest = Layout.getDesiredWidth(textLongest, 0, textLongest.length(), paint);
+ float widthPartShort = Layout.getDesiredWidth(textShort, 2, textShort.length(), paint);
+ float widthZero = Layout.getDesiredWidth(textLonger, 5, textShort.length() - 3, paint);
+ assertTrue(widthLonger > widthShort);
+ assertTrue(widthLongest > widthLonger);
+ assertEquals(0f, widthZero);
+ assertTrue(widthShort > widthPartShort);
+ }
+
+ @TestTargetNew(
+ level = TestLevel.COMPLETE,
+ method = "getDesiredWidth",
+ args = {java.lang.CharSequence.class, android.text.TextPaint.class}
+ )
+ public void testGetDesiredWidth() {
+ CharSequence textShort = "test";
+ CharSequence textLonger = "test\ngetDesiredWidth";
+ CharSequence textLongest = "test getDesiredWidth";
+ TextPaint paint = new TextPaint();
+ float widthShort = Layout.getDesiredWidth(textShort, paint);
+ float widthLonger = Layout.getDesiredWidth(textLonger, paint);
+ float widthLongest = Layout.getDesiredWidth(textLongest, paint);
+ assertTrue(widthLonger > widthShort);
+ assertTrue(widthLongest > widthLonger);
+ }
+
+ private final class MockLayout extends Layout {
+ public MockLayout(CharSequence text, TextPaint paint, int width,
+ Alignment align, float spacingmult, float spacingadd) {
+ super(text, paint, width, align, spacingmult, spacingadd);
+ }
+
+ protected boolean mockIsSpanned() {
+ return super.isSpanned();
+ }
+
+ @Override
+ public int getBottomPadding() {
+ return 0;
+ }
+
+ @Override
+ public int getEllipsisCount(int line) {
+ return 0;
+ }
+
+ @Override
+ public int getEllipsisStart(int line) {
+ return 0;
+ }
+
+ @Override
+ public boolean getLineContainsTab(int line) {
+ return false;
+ }
+
+ @Override
+ public int getLineCount() {
+ return LINE_COUNT;
+ }
+
+ @Override
+ public int getLineDescent(int line) {
+ return LINE_DESCENT;
+ }
+
+ @Override
+ public Directions getLineDirections(int line) {
+ return null;
+ }
+
+ @Override
+ public int getLineStart(int line) {
+ if (line < 0) {
+ return 0;
+ }
+ return line;
+ }
+
+ @Override
+ public int getLineTop(int line) {
+ if (line < 0) {
+ return 0;
+ }
+ return LINE_HEIGHT * (line);
+ }
+
+ @Override
+ public int getParagraphDirection(int line) {
+ return 0;
+ }
+
+ @Override
+ public int getTopPadding() {
+ return 0;
+ }
+ }
+}
OSDN Git Service
