/*

 * Copyright (c) 1996, 2016, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * @test

 * @bug 4035266 4052418 4068133 4068137 4068139 4086052 4095322 4097779

 *      4097920 4098467 4111338 4113835 4117554 4143071 4146175 4152117

 *      4152416 4153072 4158381 4214367 4217703 4638433

 * @library /java/text/testlib

 * @run main/timeout=2000 BreakIteratorTest

 * @summary test BreakIterator

 */

/*

 *

 *

 * (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved

 * (C) Copyright IBM Corp. 1996 - 1998 - All Rights Reserved

 *

 * Portions copyright (c) 2007 Sun Microsystems, Inc.

 * All Rights Reserved.

 *

 * The original version of this source code and documentation

 * is copyrighted and owned by Taligent, Inc., a wholly-owned

 * subsidiary of IBM. These materials are provided under terms

 * of a License Agreement between Taligent and Sun. This technology

 * is protected by multiple US and International patents.

 *

 * This notice and attribution to Taligent may not be removed.

 * Taligent is a registered trademark of Taligent, Inc.

 *

 * Permission to use, copy, modify, and distribute this software

 * and its documentation for NON-COMMERCIAL purposes and without

 * fee is hereby granted provided that this copyright notice

 * appears in all copies. Please refer to the file "copyright.html"

 * for further important copyright and licensing information.

 *

 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF

 * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED

 * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A

 * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR

 * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR

 * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.

 *

 */

import java.text.BreakIterator;

import java.text.CharacterIterator;

import java.text.StringCharacterIterator;

import java.util.Locale;

import java.util.Vector;

import java.util.Enumeration;

import java.io.*;

public class BreakIteratorTest extends IntlTest

{

    private BreakIterator characterBreak;

    private BreakIterator wordBreak;

    private BreakIterator lineBreak;

    private BreakIterator sentenceBreak;

    public static void main(String[] args) throws Exception {

        new BreakIteratorTest().run(args);

    }

    public BreakIteratorTest()

    {

        characterBreak = BreakIterator.getCharacterInstance();

        wordBreak = BreakIterator.getWordInstance();

        lineBreak = BreakIterator.getLineInstance();

        sentenceBreak = BreakIterator.getSentenceInstance();

    }

    //=========================================================================

    // general test subroutines

    //=========================================================================

    private void generalIteratorTest(BreakIterator bi, Vector expectedResult) {

        StringBuffer buffer = new StringBuffer();

        String text;

        for (int i = 0; i < expectedResult.size(); i++) {

            text = (String)expectedResult.elementAt(i);

            buffer.append(text);

        }

        text = buffer.toString();

        bi.setText(text);

        Vector nextResults = testFirstAndNext(bi, text);

        Vector previousResults = testLastAndPrevious(bi, text);

        logln("comparing forward and backward...");

        int errs = getErrorCount();

        compareFragmentLists("forward iteration", "backward iteration", nextResults,

                        previousResults);

        if (getErrorCount() == errs) {

            logln("comparing expected and actual...");

            compareFragmentLists("expected result", "actual result", expectedResult,

                            nextResults);

        }

        int[] boundaries = new int[expectedResult.size() + 3];

        boundaries[0] = BreakIterator.DONE;

        boundaries[1] = 0;

        for (int i = 0; i < expectedResult.size(); i++)

            boundaries[i + 2] = boundaries[i + 1] + ((String)expectedResult.elementAt(i)).

                            length();

        boundaries[boundaries.length - 1] = BreakIterator.DONE;

        testFollowing(bi, text, boundaries);

        testPreceding(bi, text, boundaries);

        testIsBoundary(bi, text, boundaries);

        doMultipleSelectionTest(bi, text);

    }

    private Vector testFirstAndNext(BreakIterator bi, String text) {

        int p = bi.first();

        int lastP = p;

        Vector<String> result = new Vector<String>();

        if (p != 0)

            errln("first() returned " + p + " instead of 0");

        while (p != BreakIterator.DONE) {

            p = bi.next();

            if (p != BreakIterator.DONE) {

                if (p <= lastP)

                    errln("next() failed to move forward: next() on position "

                                    + lastP + " yielded " + p);

                result.addElement(text.substring(lastP, p));

            }

            else {

                if (lastP != text.length())

                    errln("next() returned DONE prematurely: offset was "

                                    + lastP + " instead of " + text.length());

            }

            lastP = p;

        }

        return result;

    }

    private Vector testLastAndPrevious(BreakIterator bi, String text) {

        int p = bi.last();

        int lastP = p;

        Vector<String> result = new Vector<String>();

        if (p != text.length())

            errln("last() returned " + p + " instead of " + text.length());

        while (p != BreakIterator.DONE) {

            p = bi.previous();

            if (p != BreakIterator.DONE) {

                if (p >= lastP)

                    errln("previous() failed to move backward: previous() on position "

                                    + lastP + " yielded " + p);

                result.insertElementAt(text.substring(p, lastP), 0);

            }

            else {

                if (lastP != 0)

                    errln("previous() returned DONE prematurely: offset was "

                                    + lastP + " instead of 0");

            }

            lastP = p;

        }

        return result;

    }

    private void compareFragmentLists(String f1Name, String f2Name, Vector f1, Vector f2) {

        int p1 = 0;

        int p2 = 0;

        String s1;

        String s2;

        int t1 = 0;

        int t2 = 0;

        while (p1 < f1.size() && p2 < f2.size()) {

            s1 = (String)f1.elementAt(p1);

            s2 = (String)f2.elementAt(p2);

            t1 += s1.length();

            t2 += s2.length();

            if (s1.equals(s2)) {

                debugLogln("   >" + s1 + "<");

                ++p1;

                ++p2;

            }

            else {

                int tempT1 = t1;

                int tempT2 = t2;

                int tempP1 = p1;

                int tempP2 = p2;

                while (tempT1 != tempT2 && tempP1 < f1.size() && tempP2 < f2.size()) {

                    while (tempT1 < tempT2 && tempP1 < f1.size()) {

                        tempT1 += ((String)f1.elementAt(tempP1)).length();

                        ++tempP1;

                    }

                    while (tempT2 < tempT1 && tempP2 < f2.size()) {

                        tempT2 += ((String)f2.elementAt(tempP2)).length();

                        ++tempP2;

                    }

                }

                logln("*** " + f1Name + " has:");

                while (p1 <= tempP1 && p1 < f1.size()) {

                    s1 = (String)f1.elementAt(p1);

                    t1 += s1.length();

                    debugLogln(" *** >" + s1 + "<");

                    ++p1;

                }

                logln("***** " + f2Name + " has:");

                while (p2 <= tempP2 && p2 < f2.size()) {

                    s2 = (String)f2.elementAt(p2);

                    t2 += s2.length();

                    debugLogln(" ***** >" + s2 + "<");

                    ++p2;

                }

                errln("Discrepancy between " + f1Name + " and " + f2Name + "\n---\n" + f1 +"\n---\n" + f2);

            }

        }

    }

    private void testFollowing(BreakIterator bi, String text, int[] boundaries) {

        logln("testFollowing():");

        int p = 2;

        int i = 0;

        try {

            for (i = 0; i <= text.length(); i++) {  // change to <= when new BI code goes in

                if (i == boundaries[p])

                    ++p;

                int b = bi.following(i);

                logln("bi.following(" + i + ") -> " + b);

                if (b != boundaries[p])

                    errln("Wrong result from following() for " + i + ": expected " + boundaries[p]

                          + ", got " + b);

            }

        } catch (IllegalArgumentException illargExp) {

            errln("IllegalArgumentException caught from following() for offset: " + i);

        }

    }

    private void testPreceding(BreakIterator bi, String text, int[] boundaries) {

        logln("testPreceding():");

        int p = 0;

        int i = 0;

        try {

            for (i = 0; i <= text.length(); i++) {  // change to <= when new BI code goes in

                int b = bi.preceding(i);

                logln("bi.preceding(" + i + ") -> " + b);

                if (b != boundaries[p])

                    errln("Wrong result from preceding() for " + i + ": expected " + boundaries[p]

                          + ", got " + b);

                if (i == boundaries[p + 1])

                    ++p;

            }

        } catch (IllegalArgumentException illargExp) {

            errln("IllegalArgumentException caught from preceding() for offset: " + i);

        }

    }

    private void testIsBoundary(BreakIterator bi, String text, int[] boundaries) {

        logln("testIsBoundary():");

        int p = 1;

        boolean isB;

        for (int i = 0; i <= text.length(); i++) {  // change to <= when new BI code goes in

            isB = bi.isBoundary(i);

            logln("bi.isBoundary(" + i + ") -> " + isB);

            if (i == boundaries[p]) {

                if (!isB)

                    errln("Wrong result from isBoundary() for " + i + ": expected true, got false");

                ++p;

            }

            else {

                if (isB)

                    errln("Wrong result from isBoundary() for " + i + ": expected false, got true");

            }

        }

    }

    private void doMultipleSelectionTest(BreakIterator iterator, String testText)

    {

        logln("Multiple selection test...");

        BreakIterator testIterator = (BreakIterator)iterator.clone();

        int offset = iterator.first();

        int testOffset;

        int count = 0;

        do {

            testOffset = testIterator.first();

            testOffset = testIterator.next(count);

            logln("next(" + count + ") -> " + testOffset);

            if (offset != testOffset)

                errln("next(n) and next() not returning consistent results: for step " + count + ", next(n) returned " + testOffset + " and next() had " + offset);

            if (offset != BreakIterator.DONE) {

                count++;

                offset = iterator.next();

            }

        } while (offset != BreakIterator.DONE);

        // now do it backwards...

        offset = iterator.last();

        count = 0;

        do {

            testOffset = testIterator.last();

            testOffset = testIterator.next(count);

            logln("next(" + count + ") -> " + testOffset);

            if (offset != testOffset)

                errln("next(n) and next() not returning consistent results: for step " + count + ", next(n) returned " + testOffset + " and next() had " + offset);

            if (offset != BreakIterator.DONE) {

                count--;

                offset = iterator.previous();

            }

        } while (offset != BreakIterator.DONE);

    }

    private void doBreakInvariantTest(BreakIterator tb, String testChars)

    {

        StringBuffer work = new StringBuffer("aaa");

        int errorCount = 0;

        // a break should always occur after CR (unless followed by LF), LF, PS, and LS

        String breaks = /*"\r\n\u2029\u2028"*/"\n\u2029\u2028";

                            // change this back when new BI code is added

        for (int i = 0; i < breaks.length(); i++) {

            work.setCharAt(1, breaks.charAt(i));

            for (int j = 0; j < testChars.length(); j++) {

                work.setCharAt(0, testChars.charAt(j));

                for (int k = 0; k < testChars.length(); k++) {

                    char c = testChars.charAt(k);

                    // if a cr is followed by lf, don't do the check (they stay together)

                    if (work.charAt(1) == '\r' && (c == '\n'))

                        continue;

                    // CONTROL (Cc) and FORMAT (Cf) Characters are to be ignored

                    // for breaking purposes as per UTR14

                    int type1 = Character.getType(work.charAt(1));

                    int type2 = Character.getType(c);

                    if (type1 == Character.CONTROL || type1 == Character.FORMAT ||

                        type2 == Character.CONTROL || type2 == Character.FORMAT) {

                        continue;

                    }

                    work.setCharAt(2, c);

                    tb.setText(work.toString());

                    boolean seen2 = false;

                    for (int l = tb.first(); l != BreakIterator.DONE; l = tb.next()) {

                        if (l == 2)

                            seen2 = true;

                    }

                    if (!seen2) {

                        errln("No break between U+" + Integer.toHexString((int)(work.charAt(1)))

                                    + " and U+" + Integer.toHexString((int)(work.charAt(2))));

                        errorCount++;

                        if (errorCount >= 75)

                            return;

                    }

                }

            }

        }

    }

    private void doOtherInvariantTest(BreakIterator tb, String testChars)

    {

        StringBuffer work = new StringBuffer("a\r\na");

        int errorCount = 0;

        // a break should never occur between CR and LF

        for (int i = 0; i < testChars.length(); i++) {

            work.setCharAt(0, testChars.charAt(i));

            for (int j = 0; j < testChars.length(); j++) {

                work.setCharAt(3, testChars.charAt(j));

                tb.setText(work.toString());

                for (int k = tb.first(); k != BreakIterator.DONE; k = tb.next())

                    if (k == 2) {

                        errln("Break between CR and LF in string U+" + Integer.toHexString(

                                (int)(work.charAt(0))) + ", U+d U+a U+" + Integer.toHexString(

                                (int)(work.charAt(3))));

                        errorCount++;

                        if (errorCount >= 75)

                            return;

                    }

            }

        }

        // a break should never occur before a non-spacing mark, unless it's preceded

        // by a line terminator

        work.setLength(0);

        work.append("aaaa");

        for (int i = 0; i < testChars.length(); i++) {

            char c = testChars.charAt(i);

            if (c == '\n' || c == '\r' || c == '\u2029' || c == '\u2028' || c == '\u0003')

                continue;

            work.setCharAt(1, c);

            for (int j = 0; j < testChars.length(); j++) {

                c = testChars.charAt(j);

                if (Character.getType(c) != Character.NON_SPACING_MARK && Character.getType(c)

                        != Character.ENCLOSING_MARK)

                    continue;

                work.setCharAt(2, c);

                // CONTROL (Cc) and FORMAT (Cf) Characters are to be ignored

                // for breaking purposes as per UTR14

                int type1 = Character.getType(work.charAt(1));

                int type2 = Character.getType(work.charAt(2));

                if (type1 == Character.CONTROL || type1 == Character.FORMAT ||

                    type2 == Character.CONTROL || type2 == Character.FORMAT) {

                    continue;

                }

                tb.setText(work.toString());

                for (int k = tb.first(); k != BreakIterator.DONE; k = tb.next())

                    if (k == 2) {

                        errln("Break between U+" + Integer.toHexString((int)(work.charAt(1)))

                                + " and U+" + Integer.toHexString((int)(work.charAt(2))));

                        errorCount++;

                        if (errorCount >= 75)

                            return;

                    }

            }

        }

    }

    public void debugLogln(String s) {

        final String zeros = "0000";

        String temp;

        StringBuffer out = new StringBuffer();

        for (int i = 0; i < s.length(); i++) {

            char c = s.charAt(i);

            if (c >= ' ' && c < '\u007f')

                out.append(c);

            else {

                out.append("\\u");

                temp = Integer.toHexString((int)c);

                out.append(zeros.substring(0, 4 - temp.length()));

                out.append(temp);

            }

        }

        logln(out.toString());

    }

    //=========================================================================

    // tests

    //=========================================================================

    public void TestWordBreak() {

        Vector<String> wordSelectionData = new Vector<String>();

        wordSelectionData.addElement("12,34");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("\u00A2"); //cent sign

        wordSelectionData.addElement("\u00A3"); //pound sign

        wordSelectionData.addElement("\u00A4"); //currency sign

        wordSelectionData.addElement("\u00A5"); //yen sign

        wordSelectionData.addElement("alpha-beta-gamma");

        wordSelectionData.addElement(".");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("Badges");

        wordSelectionData.addElement("?");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("BADGES");

        wordSelectionData.addElement("!");

        wordSelectionData.addElement("?");

        wordSelectionData.addElement("!");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("We");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("don't");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("need");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("no");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("STINKING");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("BADGES");

        wordSelectionData.addElement("!");

        wordSelectionData.addElement("!");

        wordSelectionData.addElement("!");

        wordSelectionData.addElement("012.566,5");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("123.3434,900");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("1000,233,456.000");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("1,23.322%");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("123.1222");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("\u0024123,000.20");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("179.01\u0025");

        wordSelectionData.addElement("Hello");

        wordSelectionData.addElement(",");

        wordSelectionData.addElement(" ");

        wordSelectionData.addElement("how");