/*

 * Copyright (c) 2003, 2015, 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 4313885 4926319 4927634 5032610 5032622 5049968 5059533 6223711 6277261 6269946 6288823

 * @summary Basic tests of java.util.Scanner methods

 * @key randomness

 */

import java.util.*;

import java.text.*;

import java.io.*;

import java.nio.*;

import java.util.regex.*;

import java.math.*;

public class ScanTest {

    private static boolean failure = false;

    private static int failCount = 0;

    private static int NUM_SOURCE_TYPES = 2;

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

        Locale reservedLocale = Locale.getDefault();

        String lang = reservedLocale.getLanguage();

        try {

            if (!"en".equals(lang) &&

                !"zh".equals(lang) &&

                !"ko".equals(lang) &&

                !"ja".equals(lang)) {

                //Before we have resource to improve the test to be ready for

                //arbitrary locale, force the default locale to be "English"

                //for now.

                Locale.setDefault(Locale.ENGLISH);

            }

            skipTest();

            findInLineTest();

            findWithinHorizonTest();

            findInEmptyLineTest();

            removeTest();

            fromFileTest();

            ioExceptionTest();

            matchTest();

            delimiterTest();

            useLocaleTest();

            closeTest();

            cacheTest();

            cacheTest2();

            nonASCIITest();

            resetTest();

            for (int j=0; j<NUM_SOURCE_TYPES; j++) {

                hasNextTest(j);

                nextTest(j);

                hasNextPatternTest(j);

                nextPatternTest(j);

                booleanTest(j);

                byteTest(j);

                shortTest(j);

                intTest(j);

                longTest(j);

                floatTest(j);

                doubleTest(j);

                integerPatternTest(j);

                floatPatternTest(j);

                bigIntegerPatternTest(j);

                bigDecimalPatternTest(j);

                hasNextLineTest(j);

                nextLineTest(j);

                singleDelimTest(j);

            }

            // Examples

            //example1();

            //example2();

            //example3();

            // Usage cases

            useCase1();

            useCase2();

            useCase3();

            useCase4();

            useCase5();

            if (failure)

                throw new RuntimeException("Failure in the scanning tests.");

            else

                System.err.println("OKAY: All tests passed.");

        } finally {

            // restore the default locale

            Locale.setDefault(reservedLocale);

        }

    }

    public static void useCase1() throws Exception {

        File f = new File(System.getProperty("test.src", "."), "input.txt");

        Scanner sc = new Scanner(f);

        sc.findWithinHorizon("usage case 1", 0);

        String[] names = new String[4];

        for (int i=0; i<4; i++) {

            while(sc.hasNextFloat())

                sc.nextFloat();

            names[i] = sc.next();

            sc.nextLine();

        }

        if (!names[0].equals("Frank"))

            failCount++;

        if (!names[1].equals("Joe"))

            failCount++;

        if (!names[2].equals("Mary"))

            failCount++;

        if (!names[3].equals("Michelle"))

            failCount++;

        sc.close();

        report("Use case 1");

    }

    public static void useCase2() throws Exception {

        File f = new File(System.getProperty("test.src", "."), "input.txt");

        Scanner sc = new Scanner(f).useDelimiter("-");

        String testDataTag = sc.findWithinHorizon("usage case 2\n", 0);

        if (!testDataTag.equals("usage case 2\n"))

            failCount++;

        if (!sc.next().equals("cat"))

            failCount++;

        if (sc.nextInt() != 9)

            failCount++;

        if (!sc.next().equals("dog"))

            failCount++;

        if (sc.nextInt() != 6)

            failCount++;

        if (!sc.next().equals("pig"))

            failCount++;

        if (sc.nextInt() != 2)

            failCount++;

        if (!sc.next().equals(""))

            failCount++;

        if (sc.nextInt() != 5)

            failCount++;

        sc.close();

        report("Use case 2");

    }

    public static void useCase3() throws Exception {

        File f = new File(System.getProperty("test.src", "."), "input.txt");

        Scanner sc = new Scanner(f);

        String testDataTag = sc.findWithinHorizon("usage case 3\n", 0);

        if (!testDataTag.equals("usage case 3\n"))

            failCount++;

        Pattern tagPattern = Pattern.compile("@[a-z]+");

        Pattern endPattern = Pattern.compile("\\*\\/");

        String tag;

        String end = sc.findInLine(endPattern);

        while (end == null) {

            if ((tag = sc.findInLine(tagPattern)) != null) {

                String text = sc.nextLine();

                text = text.substring(0, text.length() - 1);

                //System.out.println(text);

            } else {

                sc.nextLine();

            }

            end = sc.findInLine(endPattern);

        }

        report("Use case 3");

    }

    public static void useCase4() throws Exception {

        File f = new File(System.getProperty("test.src", "."), "input.txt");

        Scanner sc = new Scanner(f);

        String testDataTag = sc.findWithinHorizon("usage case 4\n", 0);

        if (!testDataTag.equals("usage case 4\n"))

            failCount++;

        // Read some text parts of four hrefs

        String[] expected = { "Diffs", "Sdiffs", "Old", "New" };

        for (int i=0; i<4; i++) {

            sc.findWithinHorizon("<a href", 1000);

            sc.useDelimiter("[<>\n]+");

            sc.next();

            String textOfRef = sc.next();

            if (!textOfRef.equals(expected[i]))

                failCount++;

        }

        // Read some html tags using < and > as delimiters

        if (!sc.next().equals("/a"))

            failCount++;

        if (!sc.next().equals("b"))

            failCount++;

        // Scan some html tags using skip and next

        Pattern nonTagStart = Pattern.compile("[^<]+");

        Pattern tag = Pattern.compile("<[^>]+?>");

        Pattern spotAfterTag = Pattern.compile("(?<=>)");

        String[] expected2 = { "</b>", "<p>", "<ul>", "<li>" };

        sc.useDelimiter(spotAfterTag);

        int tagsFound = 0;

        while(tagsFound < 4) {

            if (!sc.hasNext(tag)) {

                // skip text between tags

                sc.skip(nonTagStart);

            }

            String tagContents = sc.next(tag);

            if (!tagContents.equals(expected2[tagsFound]))

                failCount++;

            tagsFound++;

        }

        report("Use case 4");

    }

    public static void useCase5() throws Exception {

        File f = new File(System.getProperty("test.src", "."), "input.txt");

        Scanner sc = new Scanner(f);

        String testDataTag = sc.findWithinHorizon("usage case 5\n", 0);

        if (!testDataTag.equals("usage case 5\n"))

            failCount++;

        sc.findWithinHorizon("Share Definitions", 0);

        sc.nextLine();

        sc.next("\\[([a-z]+)\\]");

        String shareName = sc.match().group(1);

        if (!shareName.equals("homes"))

            failCount++;

        String[] keys = { "comment", "browseable", "writable", "valid users" };

        String[] vals = { "Home Directories", "no", "yes", "%S" };

        for (int i=0; i<4; i++) {

            sc.useDelimiter("=");

            String key = sc.next().trim();

            if (!key.equals(keys[i]))

                failCount++;

            sc.skip("[ =]+");

            sc.useDelimiter("\n");

            String value = sc.next();

            if (!value.equals(vals[i]))

                failCount++;

            sc.nextLine();

        }

        report("Use case 5");

    }

    public static void nonASCIITest() throws Exception {

        String yourBasicTibetanNumberZero = "\u0f20";

        String yourBasicTibetanFloatingNumber = "\u0f23.\u0f27";

        String weirdMixtureOfTibetanAndASCII = "\u0f23.7";

        String weirdMixtureOfASCIIAndTibetan = "3.\u0f27";

        Scanner sc = new Scanner(yourBasicTibetanNumberZero);

        int i = sc.nextInt();

        if (i != 0)

            failCount++;

        sc = new Scanner(yourBasicTibetanFloatingNumber);

        float f = sc.nextFloat();

        if (f != Float.parseFloat("3.7"))

            failCount++;

        sc = new Scanner(weirdMixtureOfTibetanAndASCII);

        f = sc.nextFloat();

        if (f != Float.parseFloat("3.7"))

            failCount++;

        sc = new Scanner(weirdMixtureOfASCIIAndTibetan);

        f = sc.nextFloat();

        if (f != Float.parseFloat("3.7"))

            failCount++;

        report("Scanning non ASCII digits");

    }

    public static void findWithinHorizonTest() throws Exception {

        // Test with a string source

        Scanner sc = new Scanner("dog  cat     cat    dog     cat");

        try {

            sc.findWithinHorizon("dog", -1);

            failCount++;

        } catch (IllegalArgumentException iae) {

            // Correct result

        }

        if (sc.findWithinHorizon("dog", 2) != null)

            failCount++;

        if (!sc.findWithinHorizon("dog", 3).equals("dog"))

            failCount++;

        if (sc.findWithinHorizon("cat", 4) != null)

            failCount++;

        if (!sc.findWithinHorizon("cat", 5).equals("cat"))

            failCount++;

         if (sc.findWithinHorizon("cat", 7) != null)

            failCount++;

        if (sc.findWithinHorizon("dog", 7) != null)

            failCount++;

        if (!sc.findWithinHorizon("cat", 0).equals("cat"))

            failCount++;

        if (!sc.findWithinHorizon("dog", 0).equals("dog"))

            failCount++;

        if (!sc.findWithinHorizon("cat", 0).equals("cat"))

            failCount++;

        // Test with a stream source

        StutteringInputStream stutter = new StutteringInputStream();

        for (int index=0; index<stutter.length(); index++) {

            //System.out.println("index is now "+index);

            sc = new Scanner(stutter);

            String word = stutter.wordInIndex(index);

            if (word != null) {

                String result = sc.findWithinHorizon(word, index);

                if ((result == null) || (!result.equals(word)))

                    failCount++;

            }

            stutter.reset();

            word = stutter.wordBeyondIndex(index);

            sc = new Scanner(stutter);

            String result = sc.findWithinHorizon(word, index);

            if ((result != null) && (index > 0))

                failCount++;

            stutter.reset();

        }

        // We must loop to let StutteringInputStream do its magic

        for (int j=0; j<10; j++) {

            // An anchor at the end of stream should work

            stutter.reset();

            sc = new Scanner(stutter);

            String result = sc.findWithinHorizon("phant$", 0);

            if (!result.equals("phant"))

                failCount++;

            stutter.reset();

            sc = new Scanner(stutter);

            result = sc.findWithinHorizon("phant$", 54);

            if (!result.equals("phant"))

                failCount++;

            // An anchor at the end of horizon should not

            stutter.reset();

            sc = new Scanner(stutter);

            result = sc.findWithinHorizon("brummer$", 7);

            if (result != null)

                failCount++;

            // An anchor at start should work

            stutter.reset();

            sc = new Scanner(stutter);

            result = sc.findWithinHorizon("^brummer", 0);

            if (!result.equals("brummer"))

                failCount++;

        }

        report("Find to horizon test");

    }

    // StutteringInputStream returns 1 to 3 characters at a time

    static class StutteringInputStream implements Readable {

        StutteringInputStream() {

            text = "brummer hisser tort zardzard rantrant caimagator phant";

            datalen = 54;

        }

        StutteringInputStream(String text) {

            this.text = text;

            datalen = text.length();

        }

        Random generator = new Random();

        String text;

        int datalen;

        int index = 0;

        public int length() {

            return datalen;

        }

        public void reset() {

            index = 0;

        }

        public String wordInIndex(int index) {

            if (index < 7)  return null;

            if (index < 14) return "brummer";

            if (index < 19) return "hisser";

            if (index < 28) return "tort";

            if (index < 37) return "zardzard";

            if (index < 48) return "rantrant";

            return "caimagator";

        }

        public String wordBeyondIndex(int index) {

            if (index < 7)  return "brummer";

            if (index < 14) return "hisser";

            if (index < 19) return "tort";

            if (index < 28) return "zardzard";

            if (index < 37) return "rantrant";

            if (index < 48) return "caimagator";

            return "phantphant";

        }

        public int read(java.nio.CharBuffer target) throws IOException {

            if (index > datalen-1)

                return -1; // EOS

            int len = target.remaining();

            if (len > 4) // return 1 to 3 characters

                len = generator.nextInt(3) + 1;

            while ((index + len) > datalen)

                len--;

            for (int i=0; i<len; i++)

                target.put(text.charAt(index++));

            return len;

        }

    }

    public static void hasNextLineTest(int sourceType) throws Exception {

        Scanner sc = scannerFor("1\n2\n3 3\r\n4 4 4\r5", sourceType);

        if (!sc.hasNextLine()) failCount++;

        if (!sc.nextLine().equals("1")) failCount++;

        if (!sc.hasNextLine()) failCount++;

        if (sc.nextInt() != 2) failCount++;

        if (!sc.hasNextLine()) failCount++;

        if (!sc.nextLine().equals("")) failCount++;

        if (!sc.hasNextLine()) failCount++;

        if (sc.nextInt() != 3) failCount++;

        if (!sc.hasNextLine()) failCount++;

        if (!sc.nextLine().equals(" 3")) failCount++;

        if (!sc.hasNextLine()) failCount++;

        if (sc.nextInt() != 4) failCount++;

        if (!sc.hasNextLine()) failCount++;

        if (sc.nextInt() != 4) failCount++;

        if (!sc.hasNextLine()) failCount++;

        if (!sc.nextLine().equals(" 4")) failCount++;

        if (!sc.hasNextLine()) failCount++;

        if (!sc.nextLine().equals("5")) failCount++;

        if (sc.hasNextLine()) failCount++;

        sc = new Scanner("blah blah blah blah blah blah");

        if (!sc.hasNextLine()) failCount++;

        if (!sc.nextLine().equals("blah blah blah blah blah blah"))

           failCount++;

        if (sc.hasNextLine()) failCount++;

        // Go through all the lines in a file

        File f = new File(System.getProperty("test.src", "."), "input.txt");

        sc = new Scanner(f);

        String lastLine = "blah";

        while(sc.hasNextLine())

            lastLine = sc.nextLine();

        if (!lastLine.equals("# Data for usage case 6")) failCount++;

        report("Has next line test");

    }

    public static void nextLineTest(int sourceType) throws Exception {

        Scanner sc = scannerFor("1\n2\n3 3\r\n4 4 4\r5", sourceType);

        if (!sc.nextLine().equals("1"))

            failCount++;

        if (sc.nextInt() != 2)

            failCount++;

        if (!sc.nextLine().equals(""))

           failCount++;

        if (sc.nextInt() != 3)

            failCount++;

        if (!sc.nextLine().equals(" 3"))

           failCount++;

        if (sc.nextInt() != 4)

            failCount++;

        if (sc.nextInt() != 4)

            failCount++;

        if (!sc.nextLine().equals(" 4"))

           failCount++;

        if (!sc.nextLine().equals("5"))

           failCount++;

        sc = new Scanner("blah blah blah blah blah blah");

        if (!sc.nextLine().equals("blah blah blah blah blah blah"))

           failCount++;

        report("Next line test");

    }

    public static void singleDelimTest(int sourceType) throws Exception {

        Scanner sc = scannerFor("12 13  14   15    16     17      ",

                                sourceType);

        sc.useDelimiter(" ");

        for (int i=0; i<6; i++) {

            int j = sc.nextInt();

            if (j != 12 + i)

                failCount++;

            for (int k=0; k<i; k++) {

                String empty = sc.next();

                if (!empty.equals(""))

                    failCount++;

            }

        }

        report("Single delim test");

    }

    /*

     * The hasNextPattern caches a match of a pattern called the regular cache

     * The hasNextType caches a match of that type called the type cache

     * Any next must clear the caches whether it uses them or not, because

     * it advances past a token thus invalidating any cached token; any

     * hasNext must set a cache to what it finds.

     */

    public static void cacheTest() throws Exception {

        // Test clearing of the type cache

        Scanner scanner = new Scanner("777 dog");

        scanner.hasNextInt();

        scanner.findInLine("777");

        try {

            scanner.nextInt();

            System.out.println("type cache not cleared by find");

            failCount++;

        } catch (InputMismatchException ime) {

            // Correct

        }

        scanner = new Scanner("777 dog");

        scanner.hasNextInt();

        scanner.skip("777");

        try {

            scanner.nextInt();

            System.out.println("type cache not cleared by skip");

            failCount++;

        } catch (InputMismatchException ime) {

            // Correct

        }