/*
 * 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 dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.ToBeFixed;

import android.content.res.ColorStateList;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Typeface;
import android.graphics.Paint.FontMetricsInt;
import android.os.Parcel;
import android.os.Parcelable;
import android.test.AndroidTestCase;
import android.text.GetChars;
import android.text.Spannable;
import android.text.SpannableString;
import android.text.SpannableStringBuilder;
import android.text.Spanned;
import android.text.SpannedString;
import android.text.TextPaint;
import android.text.TextUtils;
import android.text.TextUtils.EllipsizeCallback;
import android.text.TextUtils.TruncateAt;
import android.text.style.BackgroundColorSpan;
import android.text.style.ReplacementSpan;
import android.text.style.TextAppearanceSpan;
import android.text.style.URLSpan;
import android.util.StringBuilderPrinter;

import java.util.ArrayList;
import java.util.regex.Pattern;

/**
 * Test {@link TextUtils}.
 */
@TestTargetClass(TextUtils.class)
public class TextUtilsTest extends AndroidTestCase {
    private static String mEllipsis;
    private int mStart;
    private int mEnd;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        mEllipsis = getEllipsis();
        resetRange();
    }

    private void resetRange() {
        mStart = -1;
        mEnd = -1;
    }

    /**
     * Get the ellipsis from system.
     * @return the string of ellipsis.
     */
    private String getEllipsis() {
        String text = "xxxxx";
        TextPaint p = new TextPaint();
        float width = p.measureText(text.substring(1));
        String re = TextUtils.ellipsize(text, p, width, TruncateAt.START).toString();
        return re.substring(0, re.indexOf("x"));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "commaEllipsize",
        args = {CharSequence.class, TextPaint.class, float.class, String.class, String.class}
    )
    @ToBeFixed(bug = "1688347 ", explanation = "The javadoc for commaEllipsize() " +
            "does not discuss any of the corner cases")
    public void testCommaEllipsize() {
        TextPaint p = new TextPaint();
        String text = "long, string, to, truncate";

        float textWidth = p.measureText("long, 3 plus");
        // avail is shorter than text width for only one item plus the appropriate ellipsis.
        // issue 1688347, the expected result for this case does not be described
        // in the javadoc of commaEllipsize().
        assertEquals("",
                TextUtils.commaEllipsize(text, p, textWidth - 1, "plus 1", "%d plus").toString());
        // avail is long enough for only one item plus the appropriate ellipsis.
        assertEquals("long, 3 plus",
                TextUtils.commaEllipsize(text, p, textWidth, "plus 1", "%d plus").toString());

        // avail is long enough for two item plus the appropriate ellipsis.
        textWidth = p.measureText("long, string, 2 more");
        assertEquals("long, string, 2 more",
                TextUtils.commaEllipsize(text, p, textWidth, "more 1", "%d more").toString());

        // avail is long enough for the whole sentence.
        textWidth = p.measureText("long, string, to, truncate");
        assertEquals("long, string, to, truncate",
                TextUtils.commaEllipsize(text, p, textWidth, "more 1", "%d more").toString());

        // the sentence is extended, avail is NOT long enough for the whole sentence.
        assertEquals("long, string, to, more 1", TextUtils.commaEllipsize(
                text + "-extended", p, textWidth, "more 1", "%d more").toString());

        // exceptional value
        assertEquals("", TextUtils.commaEllipsize(text, p, -1f, "plus 1", "%d plus").toString());

        assertEquals(text, TextUtils.commaEllipsize(
                text, p, Float.MAX_VALUE, "more 1", "%d more").toString());

        assertEquals("long, string, to, null", TextUtils.commaEllipsize(
                text + "-extended", p, textWidth, null, "%d more").toString());

        try {
            TextUtils.commaEllipsize(null, p, textWidth, "plus 1", "%d plus");
            fail("Should throw NullPointerException");
        } catch (NullPointerException e) {
            // issue 1688347, not clear what is supposed to happen if the text to truncate is null.
        }

        try {
            TextUtils.commaEllipsize(text, null, textWidth, "plus 1", "%d plus");
            fail("Should throw NullPointerException");
        } catch (NullPointerException e) {
            // issue 1688347, not clear what is supposed to happen if TextPaint is null.
        }

        try {
            TextUtils.commaEllipsize(text, p, textWidth, "plus 1", null);
            fail("Should throw NullPointerException");
        } catch (NullPointerException e) {
            // issue 1688347, not clear what is supposed to happen
            // if the string for "%d more" in the current locale is null.
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "concat",
        args = {CharSequence[].class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for concat() is incomplete." +
            "1. doesn't explain @param and @return" +
            "2. doesn't describe the expected result when parameter is empty" +
            "3. doesn't discuss the case that parameter is expectional.")
    public void testConcat() {
        // issue 1695243
        // the javadoc for concat() doesn't describe the expected result when parameter is empty.
        assertEquals("", TextUtils.concat().toString());

        assertEquals("first", TextUtils.concat("first").toString());

        assertEquals("first, second", TextUtils.concat("first", ", ", "second").toString());

        SpannableString string1 = new SpannableString("first");
        SpannableString string2 = new SpannableString("second");
        final String url = "www.test_url.com";
        URLSpan urlSpan = new URLSpan(url);
        string1.setSpan(urlSpan, 0, string1.length() - 1, Spanned.SPAN_INCLUSIVE_INCLUSIVE);
        BackgroundColorSpan bgColorSpan = new BackgroundColorSpan(Color.GREEN);
        string2.setSpan(bgColorSpan, 0, string2.length() - 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);

        final String comma = ", ";
        Spanned strResult = (Spanned) TextUtils.concat(string1, comma, string2);
        assertEquals(string1.toString() + comma + string2.toString(), strResult.toString());
        Object spans[] = strResult.getSpans(0, strResult.length(), Object.class);
        assertEquals(2, spans.length);
        assertTrue(spans[0] instanceof URLSpan);
        assertEquals(url, ((URLSpan) spans[0]).getURL());
        assertTrue(spans[1] instanceof BackgroundColorSpan);
        assertEquals(Color.GREEN, ((BackgroundColorSpan) spans[1]).getBackgroundColor());
        assertEquals(0, strResult.getSpanStart(urlSpan));
        assertEquals(string1.length() - 1, strResult.getSpanEnd(urlSpan));
        assertEquals(string1.length() + comma.length(), strResult.getSpanStart(bgColorSpan));
        assertEquals(strResult.length() - 1, strResult.getSpanEnd(bgColorSpan));

        assertEquals(string1, TextUtils.concat(string1));

        // issue 1695243, the javadoc for concat() doesn't describe
        // the expected result when parameters are null.
        assertEquals(null, TextUtils.concat((CharSequence) null));

        try {
            TextUtils.concat((CharSequence[]) null);
            fail("Should throw NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "copySpansFrom",
        args = {Spanned.class, int.class, int.class, Class.class, Spannable.class, int.class}
    )
    @ToBeFixed(bug = "1688347", explanation = "the javadoc for copySpansFrom() does not exist.")
    public void testCopySpansFrom() {
        Object[] spans;
        String text = "content";
        SpannableString source1 = new SpannableString(text);
        int midPos = source1.length() / 2;
        final String url = "www.test_url.com";
        URLSpan urlSpan = new URLSpan(url);
        source1.setSpan(urlSpan, 0, midPos, Spanned.SPAN_INCLUSIVE_INCLUSIVE);
        BackgroundColorSpan bgColorSpan = new BackgroundColorSpan(Color.GREEN);
        source1.setSpan(bgColorSpan, midPos - 1,
                source1.length() - 1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);

        // normal test
        SpannableString dest1 = new SpannableString(text);
        TextUtils.copySpansFrom(source1, 0, source1.length(), Object.class, dest1, 0);
        spans = dest1.getSpans(0, dest1.length(), Object.class);
        assertEquals(2, spans.length);
        assertTrue(spans[0] instanceof URLSpan);
        assertEquals(url, ((URLSpan) spans[0]).getURL());
        assertTrue(spans[1] instanceof BackgroundColorSpan);
        assertEquals(Color.GREEN, ((BackgroundColorSpan) spans[1]).getBackgroundColor());
        assertEquals(0, dest1.getSpanStart(urlSpan));
        assertEquals(midPos, dest1.getSpanEnd(urlSpan));
        assertEquals(Spanned.SPAN_INCLUSIVE_INCLUSIVE, dest1.getSpanFlags(urlSpan));
        assertEquals(midPos - 1, dest1.getSpanStart(bgColorSpan));
        assertEquals(source1.length() - 1, dest1.getSpanEnd(bgColorSpan));
        assertEquals(Spanned.SPAN_EXCLUSIVE_EXCLUSIVE, dest1.getSpanFlags(bgColorSpan));

        SpannableString source2 = new SpannableString(text);
        source2.setSpan(urlSpan, 0, source2.length() - 1, Spanned.SPAN_EXCLUSIVE_INCLUSIVE);
        SpannableString dest2 = new SpannableString(text);
        TextUtils.copySpansFrom(source2, 0, source2.length(), Object.class, dest2, 0);
        spans = dest2.getSpans(0, dest2.length(), Object.class);
        assertEquals(1, spans.length);
        assertTrue(spans[0] instanceof URLSpan);
        assertEquals(url, ((URLSpan) spans[0]).getURL());
        assertEquals(0, dest2.getSpanStart(urlSpan));
        assertEquals(source2.length() - 1, dest2.getSpanEnd(urlSpan));
        assertEquals(Spanned.SPAN_EXCLUSIVE_INCLUSIVE, dest2.getSpanFlags(urlSpan));

        SpannableString dest3 = new SpannableString(text);
        TextUtils.copySpansFrom(source2, 0, source2.length(), BackgroundColorSpan.class, dest3, 0);
        spans = dest3.getSpans(0, dest3.length(), Object.class);
        assertEquals(0, spans.length);
        TextUtils.copySpansFrom(source2, 0, source2.length(), URLSpan.class, dest3, 0);
        spans = dest3.getSpans(0, dest3.length(), Object.class);
        assertEquals(1, spans.length);

        SpannableString dest4 = new SpannableString("short");
        try {
            TextUtils.copySpansFrom(source2, 0, source2.length(), Object.class, dest4, 0);
            fail("Should throw IndexOutOfBoundsException");
        } catch (IndexOutOfBoundsException e) {
            // expected
        }
        TextUtils.copySpansFrom(source2, 0, dest4.length(), Object.class, dest4, 0);
        spans = dest4.getSpans(0, dest4.length(), Object.class);
        assertEquals(1, spans.length);
        assertEquals(0, dest4.getSpanStart(spans[0]));
        // issue 1688347, not clear the expected result when 'start ~ end' only
        // covered a part of the span.
        assertEquals(dest4.length(), dest4.getSpanEnd(spans[0]));

        SpannableString dest5 = new SpannableString("longer content");
        TextUtils.copySpansFrom(source2, 0, source2.length(), Object.class, dest5, 0);
        spans = dest5.getSpans(0, 1, Object.class);
        assertEquals(1, spans.length);

        dest5 = new SpannableString("longer content");
        TextUtils.copySpansFrom(source2, 0, source2.length(), Object.class, dest5, 2);
        spans = dest5.getSpans(0, 1, Object.class);
        assertEquals(0, spans.length);
        spans = dest5.getSpans(2, dest5.length(), Object.class);
        assertEquals(1, spans.length);
        try {
            TextUtils.copySpansFrom(source2, 0, source2.length(),
                    Object.class, dest5, dest5.length() - source2.length() + 2);
            fail("Should throw IndexOutOfBoundsException");
        } catch (IndexOutOfBoundsException e) {
            // expected
        }

        // issue 1688347, no javadoc about the expected behavior of the exceptional argument.
        // exceptional source start
        SpannableString dest6 = new SpannableString("exceptional test");
        TextUtils.copySpansFrom(source2, -1, source2.length(), Object.class, dest6, 0);
        spans = dest6.getSpans(0, dest6.length(), Object.class);
        assertEquals(1, spans.length);
        dest6 = new SpannableString("exceptional test");
        TextUtils.copySpansFrom(source2, Integer.MAX_VALUE, source2.length() - 1,
                    Object.class, dest6, 0);
        spans = dest6.getSpans(0, dest6.length(), Object.class);
        assertEquals(0, spans.length);

        // exceptional source end
        dest6 = new SpannableString("exceptional test");
        TextUtils.copySpansFrom(source2, 0, -1, Object.class, dest6, 0);
        spans = dest6.getSpans(0, dest6.length(), Object.class);
        assertEquals(0, spans.length);
        TextUtils.copySpansFrom(source2, 0, Integer.MAX_VALUE, Object.class, dest6, 0);
        spans = dest6.getSpans(0, dest6.length(), Object.class);
        assertEquals(1, spans.length);

        // exceptional class kind
        dest6 = new SpannableString("exceptional test");
        TextUtils.copySpansFrom(source2, 0, source2.length(), null, dest6, 0);
        spans = dest6.getSpans(0, dest6.length(), Object.class);
        assertEquals(1, spans.length);

        // exceptional destination offset
        dest6 = new SpannableString("exceptional test");
        try {
            TextUtils.copySpansFrom(source2, 0, source2.length(), Object.class, dest6, -1);
            fail("Should throw IndexOutOfBoundsException");
        } catch (IndexOutOfBoundsException e) {
            // expect
        }
        try {
            TextUtils.copySpansFrom(source2, 0, source2.length(),
                    Object.class, dest6, Integer.MAX_VALUE);
            fail("Should throw IndexOutOfBoundsException");
        } catch (IndexOutOfBoundsException e) {
            // expect
        }

        // exceptional source
        try {
            TextUtils.copySpansFrom(null, 0, source2.length(), Object.class, dest6, 0);
            fail("Should throw NullPointerException");
        } catch (NullPointerException e) {
            // expect
        }

        // exceptional destination
        try {
            TextUtils.copySpansFrom(source2, 0, source2.length(), Object.class, null, 0);
            fail("Should throw NullPointerException");
        } catch (NullPointerException e) {
            // expect
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "ellipsize",
        args = {CharSequence.class, TextPaint.class, float.class, TruncateAt.class}
    )
    @ToBeFixed(bug = "1688347", explanation = "" +
            "1. the javadoc for ellipsize() is incomplete." +
            "   - doesn't explain @param and @return" +
            "   - doesn't describe expected behavior if user pass an exceptional argument." +
            "2. ellipsize() is not defined for TruncateAt.MARQUEE. " +
            "   In the code it looks like this does the same as MIDDLE. " +
            "   In other methods, MARQUEE is equivalent to END, except for the first line.")
    public void testEllipsize() {
        TextPaint p = new TextPaint();
        
        // turn off kerning. with kerning enabled, different methods of measuring the same text
        // produce different results.
        p.setFlags(p.getFlags() & ~p.DEV_KERN_TEXT_FLAG);
        
        CharSequence text = "long string to truncate";

        float textWidth = p.measureText(mEllipsis + "uncate");
        assertEquals(mEllipsis + "uncate",
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.START).toString());

        textWidth = p.measureText("long str" + mEllipsis);
        assertEquals("long str" + mEllipsis,
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.END).toString());

        textWidth = p.measureText("long" + mEllipsis + "ate");
        assertEquals("long" + mEllipsis + "ate",
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.MIDDLE).toString());

        // issue 1688347, ellipsize() is not defined for TruncateAt.MARQUEE.
        // In the code it looks like this does the same as MIDDLE.
        // In other methods, MARQUEE is equivalent to END, except for the first line.
        assertEquals("long" + mEllipsis + "ate",
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.MARQUEE).toString());

        textWidth = p.measureText(mEllipsis);
        assertEquals(mEllipsis, TextUtils.ellipsize(text, p, textWidth, TruncateAt.END).toString());
        assertEquals("", TextUtils.ellipsize(text, p, textWidth - 1, TruncateAt.END).toString());
        assertEquals("", TextUtils.ellipsize(text, p, -1f, TruncateAt.END).toString());
        assertEquals(text,
                TextUtils.ellipsize(text, p, Float.MAX_VALUE, TruncateAt.END).toString());

        assertEquals(mEllipsis,
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.START).toString());
        assertEquals(mEllipsis,
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.MIDDLE).toString());

        try {
            TextUtils.ellipsize(text, null, textWidth, TruncateAt.MIDDLE);
            fail("Should throw NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }

        try {
            TextUtils.ellipsize(null, p, textWidth, TruncateAt.MIDDLE);
            fail("Should throw NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "ellipsize",
        args = {CharSequence.class, TextPaint.class, float.class, TruncateAt.class,
                boolean.class, EllipsizeCallback.class}
    )
    @ToBeFixed(bug = "1688347", explanation = "" +
            "1. the javadoc for ellipsize() is incomplete." +
            "   - doesn't explain @param and @return" +
            "   - doesn't describe expected behavior if user pass an exceptional argument." +
            "2. ellipsize() is not defined for TruncateAt.MARQUEE. " +
            "   In the code it looks like this does the same as MIDDLE. " +
            "   In other methods, MARQUEE is equivalent to END, except for the first line.")
    public void testEllipsizeCallback() {
        TextPaint p = new TextPaint();

        // turn off kerning. with kerning enabled, different methods of measuring the same text
        // produce different results.
        p.setFlags(p.getFlags() & ~p.DEV_KERN_TEXT_FLAG);
        
        TextUtils.EllipsizeCallback callback = new TextUtils.EllipsizeCallback() {
            public void ellipsized(final int start, final int end) {
                mStart = start;
                mEnd = end;
            }
        };

        String text = "long string to truncate";

        // TruncateAt.START, does not specify preserveLength
        resetRange();
        float textWidth = p.measureText(mEllipsis + "uncate");
        assertEquals(mEllipsis + "uncate",
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.START, false,
                        callback).toString());
        assertEquals(0, mStart);
        assertEquals(text.length() - "uncate".length(), mEnd);

        // TruncateAt.START, specify preserveLength
        resetRange();
        int ellipsisNum = text.length() - "uncate".length();
        assertEquals(getBlankString(true, ellipsisNum) + "uncate",
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.START, true,
                        callback).toString());
        assertEquals(0, mStart);
        assertEquals(text.length() - "uncate".length(), mEnd);

        // TruncateAt.END, specify preserveLength
        resetRange();
        textWidth = p.measureText("long str" + mEllipsis);
        ellipsisNum = text.length() - "long str".length();
        assertEquals("long str" + getBlankString(true, ellipsisNum),
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.END, true, callback).toString());
        assertEquals("long str".length(), mStart);
        assertEquals(text.length(), mEnd);

        // TruncateAt.MIDDLE, specify preserveLength
        resetRange();
        textWidth = p.measureText("long" + mEllipsis + "ate");
        ellipsisNum = text.length() - "long".length() - "ate".length();
        assertEquals("long" + getBlankString(true, ellipsisNum) + "ate",
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.MIDDLE, true,
                        callback).toString());
        assertEquals("long".length(), mStart);
        assertEquals(text.length() - "ate".length(), mEnd);

        // TruncateAt.MIDDLE, specify preserveLength, but does not specify callback.
        resetRange();
        assertEquals("long" + getBlankString(true, ellipsisNum) + "ate",
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.MIDDLE, true,
                        null).toString());
        assertEquals(-1, mStart);
        assertEquals(-1, mEnd);

        // TruncateAt.MARQUEE, specify preserveLength
        // issue 1688347, ellipsize() is not defined for TruncateAt.MARQUEE.
        // In the code it looks like this does the same as MIDDLE.
        // In other methods, MARQUEE is equivalent to END, except for the first line.
        resetRange();
        textWidth = p.measureText("long" + mEllipsis + "ate");
        ellipsisNum = text.length() - "long".length() - "ate".length();
        assertEquals("long" + getBlankString(true, ellipsisNum) + "ate",
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.MARQUEE, true,
                        callback).toString());
        assertEquals("long".length(), mStart);
        assertEquals(text.length() - "ate".length(), mEnd);

        // avail is not long enough for ELLIPSIS, and preserveLength is specified.
        resetRange();
        textWidth = p.measureText(mEllipsis);
        assertEquals(getBlankString(false, text.length()),
                TextUtils.ellipsize(text, p, textWidth - 1f, TruncateAt.END, true,
                        callback).toString());
        assertEquals(0, mStart);
        assertEquals(text.length(), mEnd);

        // avail is not long enough for ELLIPSIS, and preserveLength doesn't be specified.
        resetRange();
        assertEquals("",
                TextUtils.ellipsize(text, p, textWidth - 1f, TruncateAt.END, false,
                        callback).toString());
        assertEquals(0, mStart);
        assertEquals(text.length(), mEnd);

        // avail is long enough for ELLIPSIS, and preserveLength is specified.
        resetRange();
        assertEquals(getBlankString(true, text.length()),
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.END, true, callback).toString());
        assertEquals(0, mStart);
        assertEquals(text.length(), mEnd);

        // avail is long enough for ELLIPSIS, and preserveLength doesn't be specified.
        resetRange();
        assertEquals(mEllipsis,
                TextUtils.ellipsize(text, p, textWidth, TruncateAt.END, false,
                        callback).toString());
        assertEquals(0, mStart);
        assertEquals(text.length(), mEnd);

        // avail is long enough for the whole sentence.
        resetRange();
        assertEquals(text,
                TextUtils.ellipsize(text, p, Float.MAX_VALUE, TruncateAt.END, true,
                        callback).toString());
        assertEquals(0, mStart);
        assertEquals(0, mEnd);

        textWidth = p.measureText("long str" + mEllipsis);
        try {
            TextUtils.ellipsize(text, null, textWidth, TruncateAt.END, true, callback);
        } catch (NullPointerException e) {
            // expected
        }

        try {
            TextUtils.ellipsize(null, p, textWidth, TruncateAt.END, true, callback);
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Get a blank string which is filled up by '\uFEFF'.
     *
     * @param isNeedStart - boolean whether need to start with char '\u2026' in the string.
     * @param len - int length of string.
     * @return a blank string which is filled up by '\uFEFF'.
     */
    private String getBlankString(boolean isNeedStart, int len) {
        StringBuilder buf = new StringBuilder();

        int i = 0;
        if (isNeedStart) {
            buf.append('\u2026');
            i++;
        }
        for (; i < len; i++) {
            buf.append('\uFEFF');
        }

        return buf.toString();
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "equals",
        args = {CharSequence.class, CharSequence.class}
    )
    public void testEquals() {
        // compare with itself.
        // String is a subclass of CharSequence and overrides equals().
        String string = "same object";
        assertTrue(TextUtils.equals(string, string));

        // SpannableString is a subclass of CharSequence and does NOT override equals().
        SpannableString spanString = new SpannableString("same object");
        final String url = "www.test_url.com";
        spanString.setSpan(new URLSpan(url), 0, spanString.length(),
                Spanned.SPAN_INCLUSIVE_INCLUSIVE);
        assertTrue(TextUtils.equals(spanString, spanString));

        // compare with other objects which have same content.
        assertTrue(TextUtils.equals("different object", "different object"));

        SpannableString urlSpanString = new SpannableString("same content");
        SpannableString bgColorSpanString = new SpannableString(
                "same content");
        URLSpan urlSpan = new URLSpan(url);
        urlSpanString.setSpan(urlSpan, 0, urlSpanString.length(),
                Spanned.SPAN_INCLUSIVE_INCLUSIVE);
        BackgroundColorSpan bgColorSpan = new BackgroundColorSpan(Color.GREEN);
        bgColorSpanString.setSpan(bgColorSpan, 0, bgColorSpanString.length(),
                Spanned.SPAN_INCLUSIVE_INCLUSIVE);

        assertTrue(TextUtils.equals(bgColorSpanString, urlSpanString));

        // compare with other objects which have different content.
        assertFalse(TextUtils.equals("different content A", "different content B"));
        assertFalse(TextUtils.equals(spanString, urlSpanString));
        assertFalse(TextUtils.equals(spanString, bgColorSpanString));

        // compare with null
        assertTrue(TextUtils.equals(null, null));
        assertFalse(TextUtils.equals(spanString, null));
        assertFalse(TextUtils.equals(null, string));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "expandTemplate",
        args = {CharSequence.class, CharSequence[].class}
    )
    @ToBeFixed(bug = "1695243", explanation =
            "the javadoc for expandTemplate() is incomplete." +
            "1. not clear what is supposed to happen if template or values is null." +
            "2. doesn't discuss the case that ^0 in template string.")
    public void testExpandTemplate() {
        // ^1 at the start of template string.
        assertEquals("value1 template to be expanded",
                TextUtils.expandTemplate("^1 template to be expanded", "value1").toString());
        // ^1 at the end of template string.
        assertEquals("template to be expanded value1",
                TextUtils.expandTemplate("template to be expanded ^1", "value1").toString());
        // ^1 in the middle of template string.
        assertEquals("template value1 to be expanded",
                TextUtils.expandTemplate("template ^1 to be expanded", "value1").toString());
        // ^1 followed by a '0'
        assertEquals("template value10 to be expanded",
                TextUtils.expandTemplate("template ^10 to be expanded", "value1").toString());
        // ^1 followed by a 'a'
        assertEquals("template value1a to be expanded",
                TextUtils.expandTemplate("template ^1a to be expanded", "value1").toString());
        // no ^1
        assertEquals("template ^a to be expanded",
                TextUtils.expandTemplate("template ^a to be expanded", "value1").toString());
        assertEquals("template to be expanded",
                TextUtils.expandTemplate("template to be expanded", "value1").toString());
        // two consecutive ^ in the input to produce a single ^ in the output.
        assertEquals("template ^ to be expanded",
                TextUtils.expandTemplate("template ^^ to be expanded", "value1").toString());
        // two ^ with a space in the middle.
        assertEquals("template ^ ^ to be expanded",
                TextUtils.expandTemplate("template ^ ^ to be expanded", "value1").toString());
        // ^1 follow a '^'
        assertEquals("template ^1 to be expanded",
                TextUtils.expandTemplate("template ^^1 to be expanded", "value1").toString());
        // ^1 followed by a '^'
        assertEquals("template value1^ to be expanded",
                TextUtils.expandTemplate("template ^1^ to be expanded", "value1").toString());

        // 9 replacement values
        final int MAX_SUPPORTED_VALUES_NUM = 9;
        CharSequence values[] = createCharSequenceArray(MAX_SUPPORTED_VALUES_NUM);
        String expected = "value1 value2 template value3 value4 to value5 value6" +
                " be value7 value8 expanded value9";
        String template = "^1 ^2 template ^3 ^4 to ^5 ^6 be ^7 ^8 expanded ^9";
        assertEquals(expected, TextUtils.expandTemplate(template, values).toString());

        //  only up to 9 replacement values are supported
        values = createCharSequenceArray(MAX_SUPPORTED_VALUES_NUM + 1);
        try {
            TextUtils.expandTemplate(template, values);
            fail("Should throw IllegalArgumentException!");
        } catch (IllegalArgumentException e) {
            // expect
        }

        // template string is ^0
        try {
            TextUtils.expandTemplate("template ^0 to be expanded", "value1");
        } catch (IllegalArgumentException e) {
            // issue 1695243, doesn't discuss the case that ^0 in template string.
        }

        // template string is ^0
        try {
            TextUtils.expandTemplate("template ^0 to be expanded");
        } catch (IllegalArgumentException e) {
            // issue 1695243, doesn't discuss the case that ^0 in template string.
        }

        // the template requests 2 values but only 1 is provided
        try {
            TextUtils.expandTemplate("template ^2 to be expanded", "value1");
            fail("Should throw IllegalArgumentException!");
        } catch (IllegalArgumentException e) {
            // expect
        }

        // values is null
        try {
            TextUtils.expandTemplate("template ^2 to be expanded", (CharSequence[]) null);
        } catch (NullPointerException e) {
            // expected
        }

        // the template requests 2 values but only one null value is provided
        try {
            TextUtils.expandTemplate("template ^2 to be expanded", (CharSequence) null);
            fail("Should throw IllegalArgumentException!");
        } catch (IllegalArgumentException e) {
            // expect
        }

        // the template requests 2 values and 2 values is provided, but all values are null.
        try {
            TextUtils.expandTemplate("template ^2 to be expanded",
                    (CharSequence) null, (CharSequence) null);
        } catch (NullPointerException e) {
            // expected
        }

        // the template requests 2 values but no value is provided.
        try {
            TextUtils.expandTemplate("template ^2 to be expanded");
            fail("Should throw IllegalArgumentException!");
        } catch (IllegalArgumentException e) {
            // expected
        }

        // template is null
        try {
            TextUtils.expandTemplate(null, "value1");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * Create a char sequence array with the specified length
     * @param len the length of the array
     * @return The char sequence array with the specified length.
     * The value of each item is "value[index+1]"
     */
    private CharSequence[] createCharSequenceArray(int len) {
        CharSequence array[] = new CharSequence[len];

        for (int i = 0; i < len; i++) {
            array[i] = "value" + (i + 1);
        }

        return array;
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "getChars",
        args = {CharSequence.class, int.class, int.class, char[].class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for getChars() does not exist.")
    public void testGetChars() {
        char[] destOriginal = "destination".toCharArray();
        char[] destResult = destOriginal.clone();

        // check whether GetChars.getChars() is called and with the proper parameters.
        MockGetChars mockGetChars = new MockGetChars();
        int start = 1;
        int end = destResult.length;
        int destOff = 2;
        TextUtils.getChars(mockGetChars, start, end, destResult, destOff);
        assertTrue(mockGetChars.hasCalledGetChars());
        assertEquals(start, mockGetChars.ReadGetCharsParams().start);
        assertEquals(end, mockGetChars.ReadGetCharsParams().end);
        assertEquals(destResult, mockGetChars.ReadGetCharsParams().dest);
        assertEquals(destOff, mockGetChars.ReadGetCharsParams().destoff);

        // use MockCharSequence to do the test includes corner cases.
        MockCharSequence mockCharSequence = new MockCharSequence("source string mock");
        // get chars to place at the beginning of the destination except the latest one char.
        destResult = destOriginal.clone();
        start = 0;
        end = destResult.length - 1;
        destOff = 0;
        TextUtils.getChars(mockCharSequence, start, end, destResult, destOff);
        // chars before end are copied from the mockCharSequence.
        for (int i = 0; i < end - start; i++) {
            assertEquals(mockCharSequence.charAt(start + i), destResult[destOff + i]);
        }
        // chars after end doesn't be changed.
        for (int i = destOff + (end - start); i < destOriginal.length; i++) {
            assertEquals(destOriginal[i], destResult[i]);
        }

        // get chars to place at the end of the destination except the earliest two chars.
        destResult = destOriginal.clone();
        start = 0;
        end = destResult.length - 2;
        destOff = 2;
        TextUtils.getChars(mockCharSequence, start, end, destResult, destOff);
        // chars before start doesn't be changed.
        for (int i = 0; i < destOff; i++) {
            assertEquals(destOriginal[i], destResult[i]);
        }
        // chars after start are copied from the mockCharSequence.
        for (int i = 0; i < end - start; i++) {
            assertEquals(mockCharSequence.charAt(start + i), destResult[destOff + i]);
        }

        // get chars to place at the end of the destination except the earliest two chars
        // and the latest one word.
        destResult = destOriginal.clone();
        start = 1;
        end = destResult.length - 2;
        destOff = 0;
        TextUtils.getChars(mockCharSequence, start, end, destResult, destOff);
        for (int i = 0; i < destOff; i++) {
            assertEquals(destOriginal[i], destResult[i]);
        }
        for (int i = 0; i < end - start; i++) {
            assertEquals(mockCharSequence.charAt(start + i), destResult[destOff + i]);
        }
        for (int i = destOff + (end - start); i < destOriginal.length; i++) {
            assertEquals(destOriginal[i], destResult[i]);
        }

        // get chars to place the whole of the destination
        destResult = destOriginal.clone();
        start = 0;
        end = destResult.length;
        destOff = 0;
        TextUtils.getChars(mockCharSequence, start, end, destResult, destOff);
        for (int i = 0; i < end - start; i++) {
            assertEquals(mockCharSequence.charAt(start + i), destResult[destOff + i]);
        }

        // exceptional start.
        end = 2;
        destOff = 0;
        destResult = destOriginal.clone();
        try {
            TextUtils.getChars(mockCharSequence, -1, end, destResult, destOff);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expected
        }

        destResult = destOriginal.clone();
        TextUtils.getChars(mockCharSequence, Integer.MAX_VALUE, end, destResult, destOff);
        for (int i = 0; i < destResult.length; i++) {
            assertEquals(destOriginal[i], destResult[i]);
        }

        // exceptional end.
        destResult = destOriginal.clone();
        start = 0;
        destOff = 0;
        try {
            TextUtils.getChars(mockCharSequence, start, destResult.length + 1, destResult, destOff);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expected
        }

        destResult = destOriginal.clone();
        TextUtils.getChars(mockCharSequence, start, -1, destResult, destOff);
        for (int i = 0; i < destResult.length; i++) {
            assertEquals(destOriginal[i], destResult[i]);
        }

        // exceptional destOff.
        destResult = destOriginal.clone();
        start = 0;
        end = 2;
        try {
            TextUtils.getChars(mockCharSequence, start, end, destResult, Integer.MAX_VALUE);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expect
        }
        try {
            TextUtils.getChars(mockCharSequence, start, end, destResult, Integer.MIN_VALUE);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expect
        }

        // exceptional source
        start = 0;
        end = 2;
        destOff =0;
        try {
            TextUtils.getChars(null, start, end, destResult, destOff);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }

        // exceptional destination
        try {
            TextUtils.getChars(mockCharSequence, start, end, null, destOff);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * MockGetChars for test.
     */
    private class MockGetChars implements GetChars {
        private boolean mHasCalledGetChars;
        private GetCharsParams mGetCharsParams = new GetCharsParams();

        class GetCharsParams {
            int start;
            int end;
            char[] dest;
            int destoff;
        }

        public boolean hasCalledGetChars() {
            return mHasCalledGetChars;
        }

        public void reset() {
            mHasCalledGetChars = false;
        }

        public GetCharsParams ReadGetCharsParams() {
            return mGetCharsParams;
        }

        public void getChars(int start, int end, char[] dest, int destoff) {
            mHasCalledGetChars = true;
            mGetCharsParams.start = start;
            mGetCharsParams.end = end;
            mGetCharsParams.dest = dest;
            mGetCharsParams.destoff = destoff;
        }

        public char charAt(int arg0) {
            return 0;
        }

        public int length() {
            return 100;
        }

        public CharSequence subSequence(int arg0, int arg1) {
            return null;
        }
    }

    /**
     * MockCharSequence for test.
     */
    private class MockCharSequence implements CharSequence {
        private char mText[];

        public MockCharSequence() {
            this("");
        }

        public MockCharSequence(String text) {
            mText = text.toCharArray();
        }

        public char charAt(int arg0) {
            if (arg0 >= 0 && arg0 < mText.length) {
                return mText[arg0];
            }
            throw new IndexOutOfBoundsException();
        }

        public int length() {
            return mText.length;
        }

        public CharSequence subSequence(int arg0, int arg1) {
            return null;
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "getOffsetAfter",
        args = {CharSequence.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for getOffsetAfter() does not exist.")
    public void testGetOffsetAfter() {
        // the first '\uD800' is index 9, the second 'uD800' is index 16
        // the '\uDBFF' is index 26
        final int POS_FIRST_D800 = 9;       // the position of the first '\uD800'.
        final int POS_SECOND_D800 = 16;
        final int POS_FIRST_DBFF = 26;
        final int SUPPLEMENTARY_CHARACTERS_OFFSET = 2;  // the offset for a supplementary characters
        final int NORMAL_CHARACTERS_OFFSET = 1;
        SpannableString text = new SpannableString(
                "string to\uD800\uDB00 get \uD800\uDC00 offset \uDBFF\uDFFF after");
        assertEquals(0 + 1, TextUtils.getOffsetAfter(text, 0));
        assertEquals(text.length(), TextUtils.getOffsetAfter(text, text.length()));
        assertEquals(text.length(), TextUtils.getOffsetAfter(text, text.length() - 1));
        assertEquals(POS_FIRST_D800 + NORMAL_CHARACTERS_OFFSET,
                TextUtils.getOffsetAfter(text, POS_FIRST_D800));
        assertEquals(POS_SECOND_D800 + SUPPLEMENTARY_CHARACTERS_OFFSET,
                TextUtils.getOffsetAfter(text, POS_SECOND_D800));
        assertEquals(POS_FIRST_DBFF + SUPPLEMENTARY_CHARACTERS_OFFSET,
                TextUtils.getOffsetAfter(text, POS_FIRST_DBFF));

        // the CharSequence string has a span.
        MockReplacementSpan mockReplacementSpan = new MockReplacementSpan();
        text.setSpan(mockReplacementSpan, POS_FIRST_D800 - 1, text.length() - 1,
                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        assertEquals(text.length() - 1, TextUtils.getOffsetAfter(text, POS_FIRST_D800));

        try {
            TextUtils.getOffsetAfter(text, -1);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        try {
            TextUtils.getOffsetAfter(text, Integer.MAX_VALUE);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        try {
            TextUtils.getOffsetAfter(null, 0);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }
    }

    /**
     * MockReplacementSpan for test.
     */
    private class MockReplacementSpan extends ReplacementSpan {
        @Override
        public void draw(Canvas canvas, CharSequence text, int start, int end, float x, int top,
                int y, int bottom, Paint paint) {
        }

        @Override
        public int getSize(Paint paint, CharSequence text, int start, int end, FontMetricsInt fm) {
            return 0;
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "getOffsetBefore",
        args = {CharSequence.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for getOffsetBefore() does not exist.")
    public void testGetOffsetBefore() {
        // the first '\uDC00' is index 10, the second 'uDC00' is index 17
        // the '\uDFFF' is index 27
        final int POS_FIRST_DC00 = 10;
        final int POS_SECOND_DC00 = 17;
        final int POS_FIRST_DFFF = 27;
        final int SUPPLYMENTARY_CHARACTERS_OFFSET = 2;
        final int NORMAL_CHARACTERS_OFFSET = 1;
        SpannableString text = new SpannableString(
                "string to\uD700\uDC00 get \uD800\uDC00 offset \uDBFF\uDFFF before");
        assertEquals(0, TextUtils.getOffsetBefore(text, 0));
        assertEquals(0, TextUtils.getOffsetBefore(text, 1));
        assertEquals(text.length() - 1, TextUtils.getOffsetBefore(text, text.length()));
        assertEquals(POS_FIRST_DC00 + 1 - NORMAL_CHARACTERS_OFFSET,
                TextUtils.getOffsetBefore(text, POS_FIRST_DC00 + 1));
        assertEquals(POS_SECOND_DC00 + 1 - SUPPLYMENTARY_CHARACTERS_OFFSET,
                TextUtils.getOffsetBefore(text, POS_SECOND_DC00 + 1));
        assertEquals(POS_FIRST_DFFF + 1 - SUPPLYMENTARY_CHARACTERS_OFFSET,
                TextUtils.getOffsetBefore(text, POS_FIRST_DFFF + 1));

        // the CharSequence string has a span.
        MockReplacementSpan mockReplacementSpan = new MockReplacementSpan();
        text.setSpan(mockReplacementSpan, 0, POS_FIRST_DC00 + 1,
                Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
        assertEquals(0, TextUtils.getOffsetBefore(text, POS_FIRST_DC00));

        try {
            TextUtils.getOffsetBefore(text, -1);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        try {
            TextUtils.getOffsetBefore(text, Integer.MAX_VALUE);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        try {
            TextUtils.getOffsetBefore(null, POS_FIRST_DC00);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "getReverse",
        args = {CharSequence.class, int.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for getReverse() does not exist.")
    public void testGetReverse() {
        String source = "string to be reversed";
        assertEquals("gnirts", TextUtils.getReverse(source, 0, "string".length()).toString());
        assertEquals("desrever",
                TextUtils.getReverse(source, source.length() - "reversed".length(),
                        source.length()).toString());
        assertEquals("", TextUtils.getReverse(source, 0, 0).toString());

        // issue 1695243, exception is thrown after the result of some cases
        // convert to a string, is this expected?
        CharSequence result = TextUtils.getReverse(source, -1, "string".length());
        try {
            result.toString();
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        TextUtils.getReverse(source, 0, source.length() + 1);
        try {
            result.toString();
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        TextUtils.getReverse(source, "string".length(), 0);
        try {
            result.toString();
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        TextUtils.getReverse(source, 0, Integer.MAX_VALUE);
        try {
            result.toString();
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        TextUtils.getReverse(source, Integer.MIN_VALUE, "string".length());
        try {
            result.toString();
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        TextUtils.getReverse(null, 0, "string".length());
        try {
            result.toString();
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expected
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "getTrimmedLength",
        args = {CharSequence.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for getReverse() is incomplete." +
            "1. doesn't explain @param and @return." +
            "2. doesn't discuss the case that parameter is expectional.")
    public void testGetTrimmedLength() {
        assertEquals("normalstring".length(), TextUtils.getTrimmedLength("normalstring"));
        assertEquals("normal string".length(), TextUtils.getTrimmedLength("normal string"));
        assertEquals("blank before".length(), TextUtils.getTrimmedLength(" \t  blank before"));
        assertEquals("blank after".length(), TextUtils.getTrimmedLength("blank after   \n    "));
        assertEquals("blank both".length(), TextUtils.getTrimmedLength(" \t   blank both  \n "));

        char[] allTrimmedChars = new char[] {
                '\u0000', '\u0001', '\u0002', '\u0003', '\u0004', '\u0005', '\u0006', '\u0007',
                '\u0008', '\u0009', '\u0010', '\u0011', '\u0012', '\u0013', '\u0014', '\u0015',
                '\u0016', '\u0017', '\u0018', '\u0019', '\u0020'
        };
        assertEquals(0, TextUtils.getTrimmedLength(String.valueOf(allTrimmedChars)));

        try {
            TextUtils.getTrimmedLength(null);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "htmlEncode",
        args = {String.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for htmlEncode() is incomplete." +
            "1. doesn't discuss the case that parameter is expectional.")
    public void testHtmlEncode() {
        assertEquals("&lt;_html_&gt;\\ &amp;&quot;&apos;string&apos;&quot;",
                TextUtils.htmlEncode("<_html_>\\ &\"'string'\""));

         try {
             TextUtils.htmlEncode(null);
             fail("Should throw NullPointerException!");
         } catch (NullPointerException e) {
             // expected
         }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "indexOf",
        args = {CharSequence.class, char.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for indexOf() does not exist.")
    public void testIndexOf1() {
        String searchString = "string to be searched";
        final int INDEX_OF_FIRST_R = 2;     // first occurrence of 'r'
        final int INDEX_OF_FIRST_T = 1;
        final int INDEX_OF_FIRST_D = searchString.length() - 1;

        assertEquals(INDEX_OF_FIRST_T, TextUtils.indexOf(searchString, 't'));
        assertEquals(INDEX_OF_FIRST_R, TextUtils.indexOf(searchString, 'r'));
        assertEquals(INDEX_OF_FIRST_D, TextUtils.indexOf(searchString, 'd'));
        assertEquals(-1, TextUtils.indexOf(searchString, 'f'));

        StringBuffer stringBuffer = new StringBuffer(searchString);
        assertEquals(INDEX_OF_FIRST_R, TextUtils.indexOf(stringBuffer, 'r'));

        StringBuilder stringBuilder = new StringBuilder(searchString);
        assertEquals(INDEX_OF_FIRST_R, TextUtils.indexOf(stringBuilder, 'r'));

        MockGetChars mockGetChars = new MockGetChars();
        assertFalse(mockGetChars.hasCalledGetChars());
        TextUtils.indexOf(mockGetChars, 'r');
        assertTrue(mockGetChars.hasCalledGetChars());

        MockCharSequence mockCharSequence = new MockCharSequence(searchString);
        assertEquals(INDEX_OF_FIRST_R, TextUtils.indexOf(mockCharSequence, 'r'));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "indexOf",
        args = {CharSequence.class, char.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for indexOf() does not exist.")
    public void testIndexOf2() {
        String searchString = "string to be searched";
        final int INDEX_OF_FIRST_R = 2;
        final int INDEX_OF_SECOND_R = 16;

        assertEquals(INDEX_OF_FIRST_R, TextUtils.indexOf(searchString, 'r', 0));
        assertEquals(INDEX_OF_SECOND_R, TextUtils.indexOf(searchString, 'r', INDEX_OF_FIRST_R + 1));
        assertEquals(-1, TextUtils.indexOf(searchString, 'r', searchString.length()));
        assertEquals(INDEX_OF_FIRST_R, TextUtils.indexOf(searchString, 'r', Integer.MIN_VALUE));
        assertEquals(2, TextUtils.indexOf(searchString, 'r', Integer.MAX_VALUE));

        StringBuffer stringBuffer = new StringBuffer(searchString);
        assertEquals(INDEX_OF_SECOND_R, TextUtils.indexOf(stringBuffer, 'r', INDEX_OF_FIRST_R + 1));
        try {
            TextUtils.indexOf(stringBuffer, 'r', Integer.MIN_VALUE);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expect
        }
        assertEquals(-1, TextUtils.indexOf(stringBuffer, 'r', Integer.MAX_VALUE));

        StringBuilder stringBuilder = new StringBuilder(searchString);
        assertEquals(INDEX_OF_SECOND_R,
                TextUtils.indexOf(stringBuilder, 'r', INDEX_OF_FIRST_R + 1));

        MockGetChars mockGetChars = new MockGetChars();
        TextUtils.indexOf(mockGetChars, 'r', INDEX_OF_FIRST_R + 1);
        assertTrue(mockGetChars.hasCalledGetChars());

        MockCharSequence mockCharSequence = new MockCharSequence(searchString);
        assertEquals(INDEX_OF_SECOND_R, TextUtils.indexOf(mockCharSequence, 'r',
                INDEX_OF_FIRST_R + 1));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "indexOf",
        args = {CharSequence.class, char.class, int.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for indexOf() does not exist.")
    public void testIndexOf3() {
        String searchString = "string to be searched";
        final int INDEX_OF_FIRST_R = 2;
        final int INDEX_OF_SECOND_R = 16;

        assertEquals(INDEX_OF_FIRST_R,
                TextUtils.indexOf(searchString, 'r', 0, searchString.length()));
        assertEquals(INDEX_OF_SECOND_R, TextUtils.indexOf(searchString, 'r',
                INDEX_OF_FIRST_R + 1, searchString.length()));
        assertEquals(-1, TextUtils.indexOf(searchString, 'r',
                INDEX_OF_FIRST_R + 1, INDEX_OF_SECOND_R));

        try {
            TextUtils.indexOf(searchString, 'r', Integer.MIN_VALUE, INDEX_OF_SECOND_R);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expect
        }
        assertEquals(-1,
                TextUtils.indexOf(searchString, 'r', Integer.MAX_VALUE, INDEX_OF_SECOND_R));
        assertEquals(-1, TextUtils.indexOf(searchString, 'r', 0, Integer.MIN_VALUE));
        try {
            TextUtils.indexOf(searchString, 'r', 0, Integer.MAX_VALUE);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expect
        }

        StringBuffer stringBuffer = new StringBuffer(searchString);
        assertEquals(INDEX_OF_SECOND_R, TextUtils.indexOf(stringBuffer, 'r',
                INDEX_OF_FIRST_R + 1, searchString.length()));

        StringBuilder stringBuilder = new StringBuilder(searchString);
        assertEquals(INDEX_OF_SECOND_R, TextUtils.indexOf(stringBuilder, 'r',
                INDEX_OF_FIRST_R + 1, searchString.length()));

        MockGetChars mockGetChars = new MockGetChars();
        TextUtils.indexOf(mockGetChars, 'r', INDEX_OF_FIRST_R + 1, searchString.length());
        assertTrue(mockGetChars.hasCalledGetChars());

        MockCharSequence mockCharSequence = new MockCharSequence(searchString);
        assertEquals(INDEX_OF_SECOND_R, TextUtils.indexOf(mockCharSequence, 'r',
                INDEX_OF_FIRST_R + 1, searchString.length()));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "indexOf",
        args = {CharSequence.class, CharSequence.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for indexOf() does not exist.")
    public void testIndexOf4() {
        String searchString = "string to be searched by string";
        final int SEARCH_INDEX = 13;

        assertEquals(0, TextUtils.indexOf(searchString, "string"));
        assertEquals(SEARCH_INDEX, TextUtils.indexOf(searchString, "search"));
        assertEquals(-1, TextUtils.indexOf(searchString, "tobe"));
        assertEquals(0, TextUtils.indexOf(searchString, ""));

        StringBuffer stringBuffer = new StringBuffer(searchString);
        assertEquals(SEARCH_INDEX, TextUtils.indexOf(stringBuffer, "search"));

        StringBuilder stringBuilder = new StringBuilder(searchString);
        assertEquals(SEARCH_INDEX, TextUtils.indexOf(stringBuilder, "search"));

        MockGetChars mockGetChars = new MockGetChars();
        TextUtils.indexOf(mockGetChars, "search");
        assertTrue(mockGetChars.hasCalledGetChars());

        MockCharSequence mockCharSequence = new MockCharSequence(searchString);
        assertEquals(SEARCH_INDEX, TextUtils.indexOf(mockCharSequence, "search"));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "indexOf",
        args = {CharSequence.class, CharSequence.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for indexOf() does not exist.")
    public void testIndexOf5() {
        String searchString = "string to be searched by string";
        final int INDEX_OF_FIRST_STRING = 0;
        final int INDEX_OF_SECOND_STRING = 25;

        assertEquals(INDEX_OF_FIRST_STRING, TextUtils.indexOf(searchString, "string", 0));
        assertEquals(INDEX_OF_SECOND_STRING, TextUtils.indexOf(searchString, "string",
                INDEX_OF_FIRST_STRING + 1));
        assertEquals(-1, TextUtils.indexOf(searchString, "string", INDEX_OF_SECOND_STRING + 1));
        assertEquals(INDEX_OF_FIRST_STRING, TextUtils.indexOf(searchString, "string",
                Integer.MIN_VALUE));
        assertEquals(0, TextUtils.indexOf(searchString, "string", Integer.MAX_VALUE));

        assertEquals(1, TextUtils.indexOf(searchString, "", 1));
        assertEquals(Integer.MAX_VALUE, TextUtils.indexOf(searchString, "", Integer.MAX_VALUE));

        assertEquals(0, TextUtils.indexOf(searchString, searchString, 0));
        assertEquals(-1, TextUtils.indexOf(searchString, searchString + "longer needle", 0));

        StringBuffer stringBuffer = new StringBuffer(searchString);
        assertEquals(INDEX_OF_SECOND_STRING, TextUtils.indexOf(stringBuffer, "string",
                INDEX_OF_FIRST_STRING + 1));
        try {
            TextUtils.indexOf(stringBuffer, "string", Integer.MIN_VALUE);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expect
        }
        assertEquals(-1, TextUtils.indexOf(stringBuffer, "string", Integer.MAX_VALUE));

        StringBuilder stringBuilder = new StringBuilder(searchString);
        assertEquals(INDEX_OF_SECOND_STRING, TextUtils.indexOf(stringBuilder, "string",
                INDEX_OF_FIRST_STRING + 1));

        MockGetChars mockGetChars = new MockGetChars();
        assertFalse(mockGetChars.hasCalledGetChars());
        TextUtils.indexOf(mockGetChars, "string", INDEX_OF_FIRST_STRING + 1);
        assertTrue(mockGetChars.hasCalledGetChars());

        MockCharSequence mockCharSequence = new MockCharSequence(searchString);
        assertEquals(INDEX_OF_SECOND_STRING, TextUtils.indexOf(mockCharSequence, "string",
                INDEX_OF_FIRST_STRING + 1));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "indexOf",
        args = {CharSequence.class, CharSequence.class, int.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for indexOf() does not exist.")
    public void testIndexOf6() {
        String searchString = "string to be searched by string";
        final int INDEX_OF_FIRST_STRING = 0;
        final int INDEX_OF_SECOND_STRING = 25;

        assertEquals(INDEX_OF_FIRST_STRING, TextUtils.indexOf(searchString, "string", 0,
                searchString.length()));
        assertEquals(INDEX_OF_SECOND_STRING, TextUtils.indexOf(searchString, "string",
                INDEX_OF_FIRST_STRING + 1, searchString.length()));
        assertEquals(-1, TextUtils.indexOf(searchString, "string", INDEX_OF_FIRST_STRING + 1,
                INDEX_OF_SECOND_STRING - 1));
        assertEquals(INDEX_OF_FIRST_STRING, TextUtils.indexOf(searchString, "string",
                Integer.MIN_VALUE, INDEX_OF_SECOND_STRING - 1));
        assertEquals(0, TextUtils.indexOf(searchString, "string", Integer.MAX_VALUE,
                INDEX_OF_SECOND_STRING - 1));

        assertEquals(INDEX_OF_SECOND_STRING, TextUtils.indexOf(searchString, "string",
                INDEX_OF_FIRST_STRING + 1, Integer.MIN_VALUE));
        assertEquals(INDEX_OF_SECOND_STRING, TextUtils.indexOf(searchString, "string",
                INDEX_OF_FIRST_STRING + 1, Integer.MAX_VALUE));

        StringBuffer stringBuffer = new StringBuffer(searchString);
        assertEquals(INDEX_OF_SECOND_STRING, TextUtils.indexOf(stringBuffer, "string",
                INDEX_OF_FIRST_STRING + 1, searchString.length()));
        try {
            TextUtils.indexOf(stringBuffer, "string", Integer.MIN_VALUE,
                    INDEX_OF_SECOND_STRING - 1);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expect
        }
        assertEquals(-1, TextUtils.indexOf(stringBuffer, "string", Integer.MAX_VALUE,
                searchString.length()));
        assertEquals(INDEX_OF_SECOND_STRING, TextUtils.indexOf(stringBuffer,
                "string", INDEX_OF_FIRST_STRING + 1, Integer.MIN_VALUE));
        assertEquals(INDEX_OF_SECOND_STRING, TextUtils.indexOf(stringBuffer,
                "string", INDEX_OF_FIRST_STRING + 1, Integer.MAX_VALUE));

        StringBuilder stringBuilder = new StringBuilder(searchString);
        assertEquals(INDEX_OF_SECOND_STRING, TextUtils.indexOf(stringBuilder, "string",
                INDEX_OF_FIRST_STRING + 1, searchString.length()));

        MockGetChars mockGetChars = new MockGetChars();
        TextUtils.indexOf(mockGetChars, "string", INDEX_OF_FIRST_STRING + 1, searchString.length());
        assertTrue(mockGetChars.hasCalledGetChars());

        MockCharSequence mockCharSequence = new MockCharSequence(searchString);
        assertEquals(INDEX_OF_SECOND_STRING, TextUtils.indexOf(mockCharSequence, "string",
                INDEX_OF_FIRST_STRING + 1, searchString.length()));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "isDigitsOnly",
        args = {CharSequence.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for isDigitsOnly() is incomplete.")
    public void testIsDigitsOnly() {
        assertFalse(TextUtils.isDigitsOnly("no digit"));
        assertFalse(TextUtils.isDigitsOnly("character and 56 digits"));
        assertTrue(TextUtils.isDigitsOnly("0123456789"));
        assertFalse(TextUtils.isDigitsOnly("1234 56789"));

        try {
            TextUtils.isDigitsOnly(null);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // issue 1695243, not clear what is supposed result if the CharSequence is null.
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "isEmpty",
        args = {CharSequence.class}
    )
    public void testIsEmpty() {
        assertFalse(TextUtils.isEmpty("not empty"));
        assertFalse(TextUtils.isEmpty("    "));
        assertTrue(TextUtils.isEmpty(""));
        assertTrue(TextUtils.isEmpty(null));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "isGraphic",
        args = {char.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for isGraphic() is incomplete.")
    public void testIsGraphicChar() {
        assertTrue(TextUtils.isGraphic('a'));
        assertTrue(TextUtils.isGraphic("\uBA00"));

        // LINE_SEPARATOR
        assertFalse(TextUtils.isGraphic('\u2028'));

        // PARAGRAPH_SEPARATOR
        assertFalse(TextUtils.isGraphic('\u2029'));

        // CONTROL
        assertFalse(TextUtils.isGraphic('\u0085'));

        // UNASSIGNED
        assertFalse(TextUtils.isGraphic('\u0D00'));

        // SURROGATE
        assertFalse(TextUtils.isGraphic('\uD800'));

        // SPACE_SEPARATOR
        assertFalse(TextUtils.isGraphic('\u0020'));

        try {
            assertFalse(TextUtils.isGraphic((Character) null));
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "isGraphic",
        args = {CharSequence.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for isGraphic() is incomplete.")
    public void testIsGraphicCharSequence() {
        assertTrue(TextUtils.isGraphic("printable characters"));

        assertFalse(TextUtils.isGraphic("\u2028\u2029\u0085\u0D00\uD800\u0020"));

        assertTrue(TextUtils.isGraphic("a\u2028\u2029\u0085\u0D00\uD800\u0020"));

        try {
            TextUtils.isGraphic(null);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }
    }

    @SuppressWarnings("unchecked")
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "join",
        args = {CharSequence.class, Iterable.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for join() is incomplete.")
    public void testJoin1() {
        ArrayList<CharSequence> charTokens = new ArrayList<CharSequence>();
        charTokens.add("string1");
        charTokens.add("string2");
        charTokens.add("string3");
        assertEquals("string1|string2|string3", TextUtils.join("|", charTokens));
        assertEquals("string1; string2; string3", TextUtils.join("; ", charTokens));
        assertEquals("string1string2string3", TextUtils.join("", charTokens));

        // issue 1695243, not clear what is supposed result if the delimiter or tokens are null.
        assertEquals("string1nullstring2nullstring3", TextUtils.join(null, charTokens));
        try {
            TextUtils.join("|", (Iterable) null);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expect
        }

        ArrayList<SpannableString> spannableStringTokens = new ArrayList<SpannableString>();
        spannableStringTokens.add(new SpannableString("span 1"));
        spannableStringTokens.add(new SpannableString("span 2"));
        spannableStringTokens.add(new SpannableString("span 3"));
        assertEquals("span 1;span 2;span 3", TextUtils.join(";", spannableStringTokens));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "join",
        args = {CharSequence.class, Object[].class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for join() is incomplete.")
    public void testJoin2() {
        CharSequence[] charTokens = new CharSequence[] { "string1", "string2", "string3" };
        assertEquals("string1|string2|string3", TextUtils.join("|", charTokens));
        assertEquals("string1; string2; string3", TextUtils.join("; ", charTokens));
        assertEquals("string1string2string3", TextUtils.join("", charTokens));

        // issue 1695243, not clear what is supposed result if the delimiter or tokens are null.
        assertEquals("string1nullstring2nullstring3", TextUtils.join(null, charTokens));
        try {
            TextUtils.join("|", (Object[]) null);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expect
        }

        SpannableString[] spannableStringTokens = new SpannableString[] {
                new SpannableString("span 1"),
                new SpannableString("span 2"),
                new SpannableString("span 3") };
        assertEquals("span 1;span 2;span 3", TextUtils.join(";", spannableStringTokens));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "lastIndexOf",
        args = {CharSequence.class, char.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for lastIndexOf() does not exist.")
    public void testLastIndexOf1() {
        String searchString = "string to be searched";
        final int INDEX_OF_LAST_R = 16;
        final int INDEX_OF_LAST_T = 7;
        final int INDEX_OF_LAST_D = searchString.length() - 1;

        assertEquals(INDEX_OF_LAST_T, TextUtils.lastIndexOf(searchString, 't'));
        assertEquals(INDEX_OF_LAST_R, TextUtils.lastIndexOf(searchString, 'r'));
        assertEquals(INDEX_OF_LAST_D, TextUtils.lastIndexOf(searchString, 'd'));
        assertEquals(-1, TextUtils.lastIndexOf(searchString, 'f'));

        StringBuffer stringBuffer = new StringBuffer(searchString);
        assertEquals(INDEX_OF_LAST_R, TextUtils.lastIndexOf(stringBuffer, 'r'));

        StringBuilder stringBuilder = new StringBuilder(searchString);
        assertEquals(INDEX_OF_LAST_R, TextUtils.lastIndexOf(stringBuilder, 'r'));

        MockGetChars mockGetChars = new MockGetChars();
        TextUtils.lastIndexOf(mockGetChars, 'r');
        assertTrue(mockGetChars.hasCalledGetChars());

        MockCharSequence mockCharSequence = new MockCharSequence(searchString);
        assertEquals(INDEX_OF_LAST_R, TextUtils.lastIndexOf(mockCharSequence, 'r'));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "lastIndexOf",
        args = {CharSequence.class, char.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for lastIndexOf() does not exist.")
    public void testLastIndexOf2() {
        String searchString = "string to be searched";
        final int INDEX_OF_FIRST_R = 2;
        final int INDEX_OF_SECOND_R = 16;

        assertEquals(INDEX_OF_SECOND_R,
                TextUtils.lastIndexOf(searchString, 'r', searchString.length()));
        assertEquals(-1, TextUtils.lastIndexOf(searchString, 'r', 0));
        assertEquals(INDEX_OF_FIRST_R,
                TextUtils.lastIndexOf(searchString, 'r', INDEX_OF_FIRST_R));
        assertEquals(-1, TextUtils.lastIndexOf(searchString, 'r', Integer.MIN_VALUE));
        assertEquals(INDEX_OF_SECOND_R,
                TextUtils.lastIndexOf(searchString, 'r', Integer.MAX_VALUE));

        StringBuffer stringBuffer = new StringBuffer(searchString);
        assertEquals(INDEX_OF_FIRST_R,
                TextUtils.lastIndexOf(stringBuffer, 'r', INDEX_OF_FIRST_R));
        assertEquals(-1, TextUtils.lastIndexOf(stringBuffer, 'r', Integer.MIN_VALUE));
        assertEquals(INDEX_OF_SECOND_R,
                TextUtils.lastIndexOf(stringBuffer, 'r', Integer.MAX_VALUE));

        StringBuilder stringBuilder = new StringBuilder(searchString);
        assertEquals(INDEX_OF_FIRST_R,
                TextUtils.lastIndexOf(stringBuilder, 'r', INDEX_OF_FIRST_R));

        MockGetChars mockGetChars = new MockGetChars();
        TextUtils.lastIndexOf(mockGetChars, 'r', INDEX_OF_FIRST_R);
        assertTrue(mockGetChars.hasCalledGetChars());

        MockCharSequence mockCharSequence = new MockCharSequence(searchString);
        assertEquals(INDEX_OF_FIRST_R,
                TextUtils.lastIndexOf(mockCharSequence, 'r', INDEX_OF_FIRST_R));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "lastIndexOf",
        args = {CharSequence.class, char.class, int.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for lastIndexOf() does not exist.")
    public void testLastIndexOf3() {
        String searchString = "string to be searched";
        final int INDEX_OF_FIRST_R = 2;
        final int INDEX_OF_SECOND_R = 16;

        assertEquals(INDEX_OF_SECOND_R, TextUtils.lastIndexOf(searchString, 'r', 0,
                searchString.length()));
        assertEquals(INDEX_OF_FIRST_R, TextUtils.lastIndexOf(searchString, 'r', 0,
                INDEX_OF_SECOND_R - 1));
        assertEquals(-1, TextUtils.lastIndexOf(searchString, 'r', 0, INDEX_OF_FIRST_R - 1));

        try {
            TextUtils.lastIndexOf(searchString, 'r', Integer.MIN_VALUE, INDEX_OF_SECOND_R - 1);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expect
        }
        assertEquals(-1, TextUtils.lastIndexOf(searchString, 'r', Integer.MAX_VALUE,
                INDEX_OF_SECOND_R - 1));
        assertEquals(-1, TextUtils.lastIndexOf(searchString, 'r', 0, Integer.MIN_VALUE));
        assertEquals(INDEX_OF_SECOND_R, TextUtils.lastIndexOf(searchString, 'r', 0,
                Integer.MAX_VALUE));

        StringBuffer stringBuffer = new StringBuffer(searchString);
        assertEquals(INDEX_OF_FIRST_R, TextUtils.lastIndexOf(stringBuffer, 'r', 0,
                INDEX_OF_SECOND_R - 1));

        StringBuilder stringBuilder = new StringBuilder(searchString);
        assertEquals(INDEX_OF_FIRST_R, TextUtils.lastIndexOf(stringBuilder, 'r', 0,
                INDEX_OF_SECOND_R - 1));

        MockGetChars mockGetChars = new MockGetChars();
        TextUtils.lastIndexOf(mockGetChars, 'r', 0, INDEX_OF_SECOND_R - 1);
        assertTrue(mockGetChars.hasCalledGetChars());

        MockCharSequence mockCharSequence = new MockCharSequence(searchString);
        assertEquals(INDEX_OF_FIRST_R, TextUtils.lastIndexOf(mockCharSequence, 'r', 0,
                INDEX_OF_SECOND_R - 1));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "regionMatches",
        args = {CharSequence.class, int.class, CharSequence.class, int.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for regionMatches() does not exist.")
    public void testRegionMatches() {
        assertFalse(TextUtils.regionMatches("one", 0, "two", 0, "one".length()));
        assertTrue(TextUtils.regionMatches("one", 0, "one", 0, "one".length()));
        try {
            TextUtils.regionMatches("one", 0, "one", 0, "one".length() + 1);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        String one = "Hello Android, hello World!";
        String two = "Hello World";
        // match "Hello"
        assertTrue(TextUtils.regionMatches(one, 0, two, 0, "Hello".length()));

        // match "Hello A" and "Hello W"
        assertFalse(TextUtils.regionMatches(one, 0, two, 0, "Hello A".length()));

        // match "World"
        assertTrue(TextUtils.regionMatches(one, "Hello Android, hello ".length(),
                two, "Hello ".length(), "World".length()));
        assertFalse(TextUtils.regionMatches(one, "Hello Android, hello ".length(),
                two, 0, "World".length()));

        try {
            TextUtils.regionMatches(one, Integer.MIN_VALUE, two, 0, "Hello".length());
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }
        try {
            TextUtils.regionMatches(one, Integer.MAX_VALUE, two, 0, "Hello".length());
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        try {
            TextUtils.regionMatches(one, 0, two, Integer.MIN_VALUE, "Hello".length());
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }
        try {
            TextUtils.regionMatches(one, 0, two, Integer.MAX_VALUE, "Hello".length());
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        try {
            TextUtils.regionMatches(one, 0, two, 0, Integer.MIN_VALUE);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }
        try {
            TextUtils.regionMatches(one, 0, two, 0, Integer.MAX_VALUE);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
        }

        try {
            TextUtils.regionMatches(null, 0, two, 0, "Hello".length());
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expect
        }
        try {
            TextUtils.regionMatches(one, 0, null, 0, "Hello".length());
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expect
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "replace",
        args = {CharSequence.class, String[].class, CharSequence[].class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for replace() is incomplete.")
    public void testReplace() {
        String template = "this is a string to be as the template for replacement";

        String sources[] = new String[] { "string" };
        CharSequence destinations[] = new CharSequence[] { "text" };
        SpannableStringBuilder replacedString = (SpannableStringBuilder) TextUtils.replace(template,
                sources, destinations);
        assertEquals("this is a text to be as the template for replacement",
                replacedString.toString());

        sources = new String[] {"is", "the", "for replacement"};
        destinations = new CharSequence[] {"was", "", "to be replaced"};
        replacedString = (SpannableStringBuilder)TextUtils.replace(template, sources, destinations);
        assertEquals("thwas is a string to be as  template to be replaced",
                replacedString.toString());

        sources = new String[] {"is", "for replacement"};
        destinations = new CharSequence[] {"was", "", "to be replaced"};
        replacedString = (SpannableStringBuilder)TextUtils.replace(template, sources, destinations);
        assertEquals("thwas is a string to be as the template ", replacedString.toString());

        sources = new String[] {"is", "the", "for replacement"};
        destinations = new CharSequence[] {"was", "to be replaced"};
        try {
            TextUtils.replace(template, sources, destinations);
            fail("Should throw ArrayIndexOutOfBoundsException!");
        } catch (ArrayIndexOutOfBoundsException e) {
            // expected
        }

        try {
            TextUtils.replace(null, sources, destinations);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }
        try {
            TextUtils.replace(template, null, destinations);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }
        try {
            TextUtils.replace(template, sources, null);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "split",
        args = {String.class, Pattern.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for split() is incomplete." +
            "1. not clear what is supposed result if the pattern string is empty.")
    public void testSplitPattern() {
        String testString = "abccbadecdebz";
        assertEquals(calculateCharsCount(testString, "c") + 1,
                TextUtils.split(testString, Pattern.compile("c")).length);
        assertEquals(calculateCharsCount(testString, "a") + 1,
                TextUtils.split(testString, Pattern.compile("a")).length);
        assertEquals(calculateCharsCount(testString, "z") + 1,
                TextUtils.split(testString, Pattern.compile("z")).length);
        assertEquals(calculateCharsCount(testString, "de") + 1,
                TextUtils.split(testString, Pattern.compile("de")).length);
        int totalCount = 1 + calculateCharsCount(testString, "a")
                + calculateCharsCount(testString, "b") + calculateCharsCount(testString, "c");
        assertEquals(totalCount,
                TextUtils.split(testString, Pattern.compile("[a-c]")).length);
        assertEquals(0, TextUtils.split("", Pattern.compile("a")).length);
        // issue 1695243, not clear what is supposed result if the pattern string is empty.
        assertEquals(testString.length() + 2,
                TextUtils.split(testString, Pattern.compile("")).length);

        try {
            TextUtils.split(null, Pattern.compile("a"));
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expect
        }
        try {
            TextUtils.split("abccbadecdebz", (Pattern) null);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expect
        }
    }

    /*
     * return the appearance count of searched chars in text.
     */
    private int calculateCharsCount(CharSequence text, CharSequence searches) {
        int count = 0;
        int start = TextUtils.indexOf(text, searches, 0);

        while (start != -1) {
            count++;
            start = TextUtils.indexOf(text, searches, start + 1);
        }
        return count;
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "split",
        args = {String.class, String.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for split() is incomplete." +
            "1. not clear what is supposed result if the pattern string is empty.")
    public void testSplitString() {
        String testString = "abccbadecdebz";
        assertEquals(calculateCharsCount(testString, "c") + 1,
                TextUtils.split("abccbadecdebz", "c").length);
        assertEquals(calculateCharsCount(testString, "a") + 1,
                TextUtils.split("abccbadecdebz", "a").length);
        assertEquals(calculateCharsCount(testString, "z") + 1,
                TextUtils.split("abccbadecdebz", "z").length);
        assertEquals(calculateCharsCount(testString, "de") + 1,
                TextUtils.split("abccbadecdebz", "de").length);
        assertEquals(0, TextUtils.split("", "a").length);
        // issue 1695243, not clear what is supposed result if the pattern string is empty.
        assertEquals(testString.length() + 2,
                TextUtils.split("abccbadecdebz", "").length);

        try {
            TextUtils.split(null, "a");
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expect
        }
        try {
            TextUtils.split("abccbadecdebz", (String) null);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expect
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "stringOrSpannedString",
        args = {CharSequence.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for" +
            " stringOrSpannedString() does not exist.")
    public void testStringOrSpannedString() {
        assertNull(TextUtils.stringOrSpannedString(null));

        SpannedString spannedString = new SpannedString("Spanned String");
        assertSame(spannedString, TextUtils.stringOrSpannedString(spannedString));

        SpannableString spannableString = new SpannableString("Spannable String");
        assertEquals("Spannable String",
                TextUtils.stringOrSpannedString(spannableString).toString());
        assertEquals(SpannedString.class,
                TextUtils.stringOrSpannedString(spannableString).getClass());

        StringBuffer stringBuffer = new StringBuffer("String Buffer");
        assertEquals("String Buffer",
                TextUtils.stringOrSpannedString(stringBuffer).toString());
        assertEquals(String.class,
                TextUtils.stringOrSpannedString(stringBuffer).getClass());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "substring",
        args = {CharSequence.class, int.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for substring() is incomplete." +
            "1. doesn't explain @param and @return" +
            "2. not clear what is supposed to happen if source is null." +
            "3. doesn't explain the thrown IndexOutOfBoundsException")
    public void testSubString() {
        String string = "String";
        assertSame(string, TextUtils.substring(string, 0, string.length()));
        assertEquals("Strin", TextUtils.substring(string, 0, string.length() - 1));
        assertEquals("", TextUtils.substring(string, 1, 1));

        try {
            TextUtils.substring(string, string.length(), 0);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expected
        }

        try {
            TextUtils.substring(string, -1, string.length());
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expected
        }

        try {
            TextUtils.substring(string, Integer.MAX_VALUE, string.length());
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expected
        }

        try {
            TextUtils.substring(string, 0, -1);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expected
        }

        try {
            TextUtils.substring(string, 0, Integer.MAX_VALUE);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expected
        }

        try {
            TextUtils.substring(null, 0, string.length());
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }

        StringBuffer stringBuffer = new StringBuffer("String Buffer");
        assertEquals("Strin", TextUtils.substring(stringBuffer, 0, string.length() - 1));
        assertEquals("", TextUtils.substring(stringBuffer, 1, 1));

        MockGetChars mockGetChars = new MockGetChars();
        TextUtils.substring(mockGetChars, 0, string.length());
        assertTrue(mockGetChars.hasCalledGetChars());
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "writeToParcel",
        args = {CharSequence.class, Parcel.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for writeToParcel() is incomplete." +
            "1. doesn't explain @param and @return" +
            "2. not clear is it the supposed result when the CharSequence is null.")
    public void testWriteToParcel() {
        Parcel p = Parcel.obtain();

        Parcelable.Creator<CharSequence> creator = TextUtils.CHAR_SEQUENCE_CREATOR;

        String string = "String";
        TextUtils.writeToParcel(string, p, 0);
        p.setDataPosition(0);
        assertEquals(string, creator.createFromParcel(p).toString());
        p.recycle();

        p = Parcel.obtain();
        TextUtils.writeToParcel(null, p, 0);
        p.setDataPosition(0);
        assertNull(creator.createFromParcel(p));
        p.recycle();

        p = Parcel.obtain();
        SpannableString spannableString = new SpannableString("Spannable String");
        URLSpan urlSpan = new URLSpan("URL Span");
        int urlSpanStart = spannableString.length() >> 1;
        int urlSpanEnd = spannableString.length();
        spannableString.setSpan(urlSpan, urlSpanStart, urlSpanEnd,
                Spanned.SPAN_INCLUSIVE_INCLUSIVE);
        TextUtils.writeToParcel(spannableString, p, 0);
        p.setDataPosition(0);
        SpannableString ret = (SpannableString) creator.createFromParcel(p);
        assertEquals("Spannable String", ret.toString());
        Object[] spans = ret.getSpans(0, ret.length(), Object.class);
        assertEquals(1, spans.length);
        assertEquals("URL Span", ((URLSpan) spans[0]).getURL());
        assertEquals(urlSpanStart, ret.getSpanStart(spans[0]));
        assertEquals(urlSpanEnd, ret.getSpanEnd(spans[0]));
        assertEquals(Spanned.SPAN_INCLUSIVE_INCLUSIVE, ret.getSpanFlags(spans[0]));
        p.recycle();

        p = Parcel.obtain();
        ColorStateList colors = new ColorStateList(new int[][] {
                new int[] {android.R.attr.state_focused}, new int[0]},
                new int[] {Color.rgb(0, 255, 0), Color.BLACK});
        int textSize = 20;
        TextAppearanceSpan textAppearanceSpan = new TextAppearanceSpan(
                null, Typeface.ITALIC, textSize, colors, null);
        int textAppearanceSpanStart = 0;
        int textAppearanceSpanEnd = spannableString.length() >> 1;
        spannableString.setSpan(textAppearanceSpan, textAppearanceSpanStart,
                textAppearanceSpanEnd, Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
        TextUtils.writeToParcel(spannableString, p, -1);
        p.setDataPosition(0);
        ret = (SpannableString) creator.createFromParcel(p);
        assertEquals("Spannable String", ret.toString());
        spans = ret.getSpans(0, ret.length(), Object.class);
        assertEquals(2, spans.length);
        assertEquals("URL Span", ((URLSpan) spans[0]).getURL());
        assertEquals(urlSpanStart, ret.getSpanStart(spans[0]));
        assertEquals(urlSpanEnd, ret.getSpanEnd(spans[0]));
        assertEquals(Spanned.SPAN_INCLUSIVE_INCLUSIVE, ret.getSpanFlags(spans[0]));
        assertEquals(null, ((TextAppearanceSpan) spans[1]).getFamily());

        assertEquals(Typeface.ITALIC, ((TextAppearanceSpan) spans[1]).getTextStyle());
        assertEquals(textSize, ((TextAppearanceSpan) spans[1]).getTextSize());

        assertEquals(colors.toString(), ((TextAppearanceSpan) spans[1]).getTextColor().toString());
        assertEquals(null, ((TextAppearanceSpan) spans[1]).getLinkTextColor());
        assertEquals(textAppearanceSpanStart, ret.getSpanStart(spans[1]));
        assertEquals(textAppearanceSpanEnd, ret.getSpanEnd(spans[1]));
        assertEquals(Spanned.SPAN_INCLUSIVE_EXCLUSIVE, ret.getSpanFlags(spans[1]));
        p.recycle();

        try {
            TextUtils.writeToParcel(spannableString, null, 0);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "getCapsMode",
        args = {CharSequence.class, int.class, int.class}
    )
    @ToBeFixed(bug = "1586346", explanation = "return cap mode which is NOT set in reqModes")
    public void testGetCapsMode() {
        final int CAP_MODE_ALL = TextUtils.CAP_MODE_CHARACTERS
                | TextUtils.CAP_MODE_WORDS | TextUtils.CAP_MODE_SENTENCES;
        final int CAP_MODE_CHARACTERS_AND_WORD =
                TextUtils.CAP_MODE_CHARACTERS | TextUtils.CAP_MODE_WORDS;
        String testString = "Start. Sentence word!No space before\n\t" +
                "Paragraph? (\"\'skip begin\'\"). skip end";

        // CAP_MODE_SENTENCES should be in effect in the whole text.
        for (int i = 0; i < testString.length(); i++) {
            assertEquals(TextUtils.CAP_MODE_CHARACTERS,
                    TextUtils.getCapsMode(testString, i, TextUtils.CAP_MODE_CHARACTERS));
        }

        // all modes should be in effect at the start of the text.
        assertEquals(TextUtils.CAP_MODE_WORDS,
                TextUtils.getCapsMode(testString, 0, TextUtils.CAP_MODE_WORDS));
        // issue 1586346
        assertEquals(TextUtils.CAP_MODE_WORDS,
                TextUtils.getCapsMode(testString, 0, TextUtils.CAP_MODE_SENTENCES));
        assertEquals(CAP_MODE_CHARACTERS_AND_WORD,
                TextUtils.getCapsMode(testString, 0, CAP_MODE_ALL));

        // all mode should be in effect at the position after "." or "?" or "!" + " ".
        int offset = testString.indexOf("Sentence word!");
        assertEquals(TextUtils.CAP_MODE_WORDS,
                TextUtils.getCapsMode(testString, offset, TextUtils.CAP_MODE_WORDS));
        assertEquals(TextUtils.CAP_MODE_SENTENCES,
                TextUtils.getCapsMode(testString, offset, TextUtils.CAP_MODE_SENTENCES));
        // issue 1586346
        assertEquals(CAP_MODE_CHARACTERS_AND_WORD,
                TextUtils.getCapsMode(testString, 0, CAP_MODE_ALL));

        // CAP_MODE_SENTENCES should NOT be in effect at the position after other words + " ".
        offset = testString.indexOf("word!");
        assertEquals(TextUtils.CAP_MODE_WORDS,
                TextUtils.getCapsMode(testString, offset, TextUtils.CAP_MODE_WORDS));
        assertEquals(0,
                TextUtils.getCapsMode(testString, offset, TextUtils.CAP_MODE_SENTENCES));
        // issue 1586346
        assertEquals(TextUtils.CAP_MODE_CHARACTERS,
                TextUtils.getCapsMode(testString, offset, CAP_MODE_ALL));

        // if no space after "." or "?" or "!", CAP_MODE_SENTENCES and CAP_MODE_WORDS
        // should NOT be in effect.
        offset = testString.indexOf("No space before");
        assertEquals(0,
                TextUtils.getCapsMode(testString, offset, TextUtils.CAP_MODE_WORDS));
        assertEquals(0,
                TextUtils.getCapsMode(testString, offset, TextUtils.CAP_MODE_SENTENCES));
        assertEquals(TextUtils.CAP_MODE_CHARACTERS,
                TextUtils.getCapsMode(testString, offset, CAP_MODE_ALL));

        // all mode should be in effect at a beginning of a new paragraph.
        offset = testString.indexOf("Paragraph");
        assertEquals(TextUtils.CAP_MODE_WORDS,
                TextUtils.getCapsMode(testString, offset, TextUtils.CAP_MODE_WORDS));
        // issue 1586346
        assertEquals(TextUtils.CAP_MODE_WORDS,
                TextUtils.getCapsMode(testString, offset, TextUtils.CAP_MODE_SENTENCES));
        assertEquals(CAP_MODE_CHARACTERS_AND_WORD,
                TextUtils.getCapsMode(testString, offset, CAP_MODE_ALL));

        // some special word which means the start of a sentence should be skipped.
        offset = testString.indexOf("skip begin");
        assertEquals(TextUtils.CAP_MODE_WORDS,
                TextUtils.getCapsMode(testString, offset, TextUtils.CAP_MODE_WORDS));
        assertEquals(TextUtils.CAP_MODE_SENTENCES,
                TextUtils.getCapsMode(testString, offset, TextUtils.CAP_MODE_SENTENCES));
        // issue 1586346
        assertEquals(TextUtils.CAP_MODE_SENTENCES | TextUtils.CAP_MODE_CHARACTERS,
                TextUtils.getCapsMode(testString, offset, CAP_MODE_ALL));

        // some special word which means the end of a sentence should be skipped.
        offset = testString.indexOf("skip end");
        assertEquals(TextUtils.CAP_MODE_WORDS,
                TextUtils.getCapsMode(testString, offset, TextUtils.CAP_MODE_WORDS));
        assertEquals(TextUtils.CAP_MODE_SENTENCES,
                TextUtils.getCapsMode(testString, offset, TextUtils.CAP_MODE_SENTENCES));
        // issue 1586346
        assertEquals(TextUtils.CAP_MODE_SENTENCES | TextUtils.CAP_MODE_CHARACTERS,
                TextUtils.getCapsMode(testString, offset, CAP_MODE_ALL));
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "getCapsMode",
        args = {CharSequence.class, int.class, int.class}
    )
    @ToBeFixed(bug = "1695243", explanation = "the javadoc for substring() is incomplete." +
            "1. doesn't describe the expected result when parameter is exceptional.")
    public void testGetCapsModeException() {
        String testString = "Start. Sentence word!No space before\n\t" +
                "Paragraph? (\"\'skip begin\'\"). skip end";

        int offset = testString.indexOf("Sentence word!");
        assertEquals(TextUtils.CAP_MODE_CHARACTERS,
                TextUtils.getCapsMode(null, offset, TextUtils.CAP_MODE_CHARACTERS));

        try {
            TextUtils.getCapsMode(null, offset, TextUtils.CAP_MODE_SENTENCES);
            fail("Should throw NullPointerException!");
        } catch (NullPointerException e) {
            // expected
        }

        assertEquals(0, TextUtils.getCapsMode(testString, -1, TextUtils.CAP_MODE_SENTENCES));

        try {
            TextUtils.getCapsMode(testString, testString.length() + 1,
                    TextUtils.CAP_MODE_SENTENCES);
            fail("Should throw IndexOutOfBoundsException!");
        } catch (IndexOutOfBoundsException e) {
            // expected
        }
    }

    @TestTargetNew(
        level = TestLevel.COMPLETE,
        method = "dumpSpans",
        args = {java.lang.CharSequence.class, android.util.Printer.class, java.lang.String.class}
    )
    public void testDumpSpans() {
        StringBuilder builder = new StringBuilder();
        StringBuilderPrinter printer = new StringBuilderPrinter(builder);
        CharSequence source = "test dump spans";
        String prefix = "prefix";

        assertEquals(0, builder.length());
        TextUtils.dumpSpans(source, printer, prefix);
        assertTrue(builder.length() > 0);

        builder = new StringBuilder();
        printer = new StringBuilderPrinter(builder);
        assertEquals(0, builder.length());
        SpannableString spanned = new SpannableString(source);
        spanned.setSpan(new Object(), 0, source.length(), Spanned.SPAN_INCLUSIVE_INCLUSIVE);
        TextUtils.dumpSpans(spanned, printer, prefix);
        assertTrue(builder.length() > 0);
    }
}