/*
 * Copyright (c) 2015, 2017, 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.
 */

import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;

import java.io.File;
import java.io.IOException;
import java.io.UncheckedIOException;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.regex.Matcher;
import java.util.regex.MatchResult;
import java.util.regex.Pattern;
import java.util.stream.LambdaTestHelpers;
import java.util.stream.OpTestCase;
import java.util.stream.Stream;
import java.util.stream.TestData;

import static org.testng.Assert.*;

/**
 * @test
 * @bug 8072722 8150488
 * @summary Tests of stream support in java.util.Scanner
 * @library /lib/testlibrary/bootlib
 * @build java.base/java.util.stream.OpTestCase
 * @run testng/othervm ScannerStreamTest
 */

@Test
public class ScannerStreamTest extends OpTestCase {

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

    @DataProvider(name = "Tokens")
    public static Object[][] makeTokensTestData() {
        // each inner array is [String description, String input, String delimiter]
        // delimiter may be null
        List<Object[]> data = new ArrayList<>();

        data.add(new Object[] { "default delimiter", "abc def ghi",           null });
        data.add(new Object[] { "fixed delimiter",   "abc,def,,ghi",          "," });
        data.add(new Object[] { "regex delimiter",   "###abc##def###ghi###j", "#+" });

        return data.toArray(new Object[0][]);
    }

    /*
     * Creates a scanner over the input, applying a delimiter if non-null.
     */
    Scanner makeScanner(String input, String delimiter) {
        Scanner sc = new Scanner(input);
        if (delimiter != null) {
            sc.useDelimiter(delimiter);
        }
        return sc;
    }

    /*
     * Given input and a delimiter, tests that tokens() returns the same
     * results that would be provided by a Scanner hasNext/next loop.
     */
    @Test(dataProvider = "Tokens")
    public void tokensTest(String description, String input, String delimiter) {
        // derive expected result by using conventional loop
        Scanner sc = makeScanner(input, delimiter);
        List<String> expected = new ArrayList<>();
        while (sc.hasNext()) {
            expected.add(sc.next());
        }

        Supplier<Stream<String>> ss = () -> makeScanner(input, delimiter).tokens();
        withData(TestData.Factory.ofSupplier(description, ss))
                .stream(LambdaTestHelpers.identity())
                .expectedResult(expected)
                .exercise();
    }

    /*
     * Creates a Scanner over the given input file.
     */
    Scanner makeFileScanner(File file) {
        try {
            return new Scanner(file, "UTF-8");
        } catch (IOException ioe) {
            throw new UncheckedIOException(ioe);
        }
    }

    /*
     * Tests that the matches produced by findAll(pat) are the same
     * as what are returned by findWithinHorizon(pat, 0). This tests
     * a single pattern against a single input file.
     */
    public void findAllFileTest() {
        // derive expected result by using conventional loop
        Pattern pat = Pattern.compile("[A-Z]{7,}");
        List<String> expected = new ArrayList<>();

        try (Scanner sc = makeFileScanner(inputFile)) {
            String match;
            while ((match = sc.findWithinHorizon(pat, 0)) != null) {
                expected.add(match);
            }
        }

        Supplier<Stream<String>> ss =
            () -> makeFileScanner(inputFile).findAll(pat).map(MatchResult::group);

        withData(TestData.Factory.ofSupplier("findAllFileTest", ss))
                .stream(LambdaTestHelpers.identity())
                .expectedResult(expected)
                .exercise();
    }

    @DataProvider(name = "FindAllZero")
    public static Object[][] makeFindAllZeroTestData() {
        // each inner array is [String input, String patternString]
        List<Object[]> data = new ArrayList<>();

        data.add(new Object[] { "aaaaa",        "a*" });
        data.add(new Object[] { "aaaaab",       "a*" });
        data.add(new Object[] { "aaaaabb",      "a*" });
        data.add(new Object[] { "aaaaabbb",     "a*" });
        data.add(new Object[] { "aaabbaaaa",    "a*" });
        data.add(new Object[] { "aaabbaaaab",   "a*" });
        data.add(new Object[] { "aaabbaaaabb",  "a*" });
        data.add(new Object[] { "aaabbaaaabbb", "a*" });
        data.add(new Object[] { "aaabbaaaa",    "a*|b*" });
        data.add(new Object[] { "aaabbaaaab",   "a*|b*" });
        data.add(new Object[] { "aaabbaaaabb",  "a*|b*" });
        data.add(new Object[] { "aaabbaaaabbb", "a*|b*" });

        return data.toArray(new Object[0][]);
    }

    /*
     * Tests findAll() using a pattern against an input string.
     * The results from findAll() should equal the results obtained
     * using a loop around Matcher.find().
     *
     * The provided regexes should allow zero-length matches.
     * This primarily tests the auto-advance feature of findAll() that
     * occurs if the regex match is of zero length to see if it has the
     * same behavior as Matcher.find()'s auto-advance (JDK-8150488).
     * Without auto-advance, findAll() would return an infinite stream
     * of zero-length matches. Apply a limit to the stream so
     * that an infinite stream will be truncated. The limit must be
     * high enough that the resulting truncated stream won't be
     * mistaken for a correct expected result.
     */
    @Test(dataProvider = "FindAllZero")
    public void findAllZeroTest(String input, String patternString) {
        Pattern pattern = Pattern.compile(patternString);

        // generate expected result using Matcher.find()
        Matcher m = pattern.matcher(input);
        List<String> expected = new ArrayList<>();
        while (m.find()) {
            expected.add(m.group());
        }

        Supplier<Stream<String>> ss = () -> new Scanner(input).findAll(pattern)
                                                              .limit(100)
                                                              .map(MatchResult::group);

        withData(TestData.Factory.ofSupplier("findAllZeroTest", ss))
                .stream(LambdaTestHelpers.identity())
                .expectedResult(expected)
                .exercise();
    }
}