198 lines
7.3 KiB
Java
198 lines
7.3 KiB
Java
/*
|
|
* 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();
|
|
}
|
|
}
|