/*
* Copyright (c) 2003, 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 4313885 4926319 4927634 5032610 5032622 5049968 5059533 6223711 6277261 6269946 6288823
* 8072722 8139414 8166261
* @summary Basic tests of java.util.Scanner methods
* @key randomness
* @modules jdk.localedata
* @run main/othervm ScanTest
*/
import java.io.*;
import java.math.*;
import java.nio.*;
import java.text.*;
import java.util.*;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.regex.*;
import java.util.stream.*;
public class ScanTest {
private static boolean failure = false;
private static int failCount = 0;
private static int NUM_SOURCE_TYPES = 2;
private static File inputFile = new File(System.getProperty("test.src", "."), "input.txt");
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();
boundaryDelimTest();
useLocaleTest();
closeTest();
cacheTest();
cacheTest2();
nonASCIITest();
resetTest();
streamCloseTest();
streamComodTest();
outOfRangeRadixTest();
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 {
try (Scanner sc = new Scanner(inputFile)) {
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++;
}
report("Use case 1");
}
public static void useCase2() throws Exception {
try (Scanner sc = new Scanner(inputFile).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++;
}
report("Use case 2");
}
public static void useCase3() throws Exception {
try (Scanner sc = new Scanner(inputFile)) {
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 {
try (Scanner sc = new Scanner(inputFile)) {
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 {
try (Scanner sc = new Scanner(inputFile)) {
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
try (Scanner sc2 = new Scanner(inputFile)) {
String lastLine = "blah";
while (sc2.hasNextLine())
lastLine = sc2.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");
}
private static void append(StringBuilder sb, char c, int n) {
for (int i = 0; i < n; i++) {
sb.append(c);
}
}
public static void boundaryDelimTest() throws Exception {
// 8139414
int i = 1019;
StringBuilder sb = new StringBuilder();
sb.append("--;");
for (int j = 0; j < 1019; ++j) {
sb.append(j%10);
}
sb.append("-;-");
String text = sb.toString();
try (Scanner scanner = new Scanner(text)) {
scanner.useDelimiter("-;(-)?");
while (scanner.hasNext()) {
scanner.next();
}
} catch (NoSuchElementException e) {
System.out.println("Caught NoSuchElementException " + e);
e.printStackTrace();
failCount++;
}
report("delim at boundary 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
}
// Test clearing of the regular cache
scanner = new Scanner("777 dog");
scanner.hasNext("777");
scanner.findInLine("777");
try {
scanner.next("777");
System.out.println("regular cache not cleared by find");
failCount++;
} catch (InputMismatchException ime) {
// Correct
}
// Test two primitive next clearing of type cache
scanner = new Scanner("777 dog");
scanner.hasNextInt();
scanner.nextLong();
try {
scanner.nextInt();
System.out.println("type cache not cleared by primitive next");
failCount++;
} catch (InputMismatchException ime) {
// Correct
}
// Test using both of them, type first
scanner = new Scanner("777 dog");
scanner.hasNext("777");
scanner.nextInt();
try {
scanner.next("777");
System.out.println("regular cache not cleared by primitive next");
failCount++;
} catch (InputMismatchException ime) {
// Correct
}
// Test using both of them, regular first
scanner = new Scanner("777 dog");
scanner.hasNext("777");
scanner.hasNextInt();
scanner.next("777");
try {
scanner.nextInt();
System.out.println("type cache not cleared by regular next");
failCount++;
} catch (InputMismatchException ime) {
// Correct
}
report("Cache test");
}
/*
* The hasNext<IntegerType>(radix) method caches a matched integer type
* with specified radix for the next next<IntegerType>(radix) invoke.
* The cache value should not be used if the next<IntegerType>(radix)
* has different radix value with the last hasNext<IntegerType>(radix).
*/
public static void cacheTest2() throws Exception {
// Test clearing of the type cache
Scanner scanner = new Scanner("10");
scanner.hasNextByte(16);
if (scanner.nextByte(10) != 10) {
System.out.println("wrong radix cache is used");
failCount++;
}
scanner = new Scanner("10");
scanner.hasNextShort(16);
if (scanner.nextShort(10) != 10) {
System.out.println("wrong radix cache is used");
failCount++;
}
scanner = new Scanner("10");
scanner.hasNextInt(16);
if (scanner.nextInt(10) != 10) {
System.out.println("wrong radix cache is used");
failCount++;
}
scanner = new Scanner("10");
scanner.hasNextLong(16);
if (scanner.nextLong(10) != 10) {
System.out.println("wrong radix cache is used");
failCount++;
}
scanner = new Scanner("10");
scanner.hasNextBigInteger(16);
if (scanner.nextBigInteger(10).intValue() != 10) {
System.out.println("wrong radix cache is used");
failCount++;
}
report("Cache test2");
}
public static void closeTest() throws Exception {
Scanner sc = new Scanner("testing");
sc.close();
sc.ioException();
sc.delimiter();
sc.useDelimiter("blah");
sc.useDelimiter(Pattern.compile("blah"));
for (Consumer<Scanner> method : methodList) {
try {
method.accept(sc);
failCount++;
} catch (IllegalStateException ise) {
// Correct
}
}
report("Close test");
}
static List<Consumer<Scanner>> methodList = Arrays.asList(
Scanner::hasNext,
Scanner::next,
sc -> sc.hasNext(Pattern.compile("blah")),
sc -> sc.next(Pattern.compile("blah")),
Scanner::hasNextBoolean,
Scanner::nextBoolean,
Scanner::hasNextByte,
Scanner::nextByte,
Scanner::hasNextShort,
Scanner::nextShort,
Scanner::hasNextInt,
Scanner::nextInt,
Scanner::hasNextLong,
Scanner::nextLong,
Scanner::hasNextFloat,
Scanner::nextFloat,
Scanner::hasNextDouble,
Scanner::nextDouble,
Scanner::hasNextBigInteger,
Scanner::nextBigInteger,
Scanner::hasNextBigDecimal,
Scanner::nextBigDecimal,
Scanner::hasNextLine,
Scanner::tokens,
sc -> sc.findAll(Pattern.compile("blah")),
sc -> sc.findAll("blah")
);
public static void removeTest() throws Exception {
Scanner sc = new Scanner("testing");
try {
sc.remove();
failCount++;
} catch (UnsupportedOperationException uoe) {
// Correct result
}
report("Remove test");
}
public static void delimiterTest() throws Exception {
Scanner sc = new Scanner("blah");
Pattern test = sc.delimiter();
if (!test.toString().equals("\\p{javaWhitespace}+"))
failCount++;
sc.useDelimiter("a");
test = sc.delimiter();
if (!test.toString().equals("a"))
failCount++;
sc.useDelimiter(Pattern.compile("b"));
test = sc.delimiter();
if (!test.toString().equals("b"))
failCount++;
report("Delimiter test");
}
public static void ioExceptionTest() throws Exception {
Readable thrower = new ThrowingReadable();
Scanner sc = new Scanner(thrower);
try {
sc.nextInt();
failCount++;
} catch (NoSuchElementException nsee) {
// Correct result
}
Exception thrown = sc.ioException();
String detail = thrown.getMessage();
if (!detail.equals("ThrowingReadable always throws"))
failCount++;
report("IOException test");
}
public static void bigIntegerPatternTest(int sourceType) throws Exception {
Scanner sc = scannerFor("23 9223372036854775817", sourceType);
if (!sc.nextBigInteger().equals(BigInteger.valueOf(23)))
failCount++;
if (!sc.nextBigInteger().equals(new BigInteger(
"9223372036854775817", 10)))
failCount++;
// Test another radix
sc = new Scanner("4a4 4A4").useRadix(16);
if (!sc.nextBigInteger().equals(new BigInteger("4a4", 16)))
failCount++;
if (!sc.nextBigInteger().equals(new BigInteger("4A4", 16)))
failCount++;
// Test alternating radices
sc = new Scanner("12 4a4 14 4f4");
if (!sc.nextBigInteger(10).equals(new BigInteger("12", 10)))
failCount++;
if (!sc.nextBigInteger(16).equals(new BigInteger("4a4", 16)))
failCount++;
if (!sc.nextBigInteger(10).equals(new BigInteger("14", 10)))
failCount++;
if (!sc.nextBigInteger(16).equals(new BigInteger("4f4", 16)))
failCount++;
// Test use of a lot of radices
for (int i=2; i<17; i++) {
sc = new Scanner("1111");
if (!sc.nextBigInteger(i).equals(new BigInteger("1111", i)))
failCount++;
}
report("BigInteger pattern");
}
public static void bigDecimalPatternTest(int sourceType) throws Exception {
Scanner sc = scannerFor("23 45.99 -45,067.444 3.4e10", sourceType);
if (!sc.nextBigDecimal().equals(BigDecimal.valueOf(23)))
failCount++;
if (!sc.nextBigDecimal().equals(new BigDecimal("45.99")))
failCount++;
if (!sc.nextBigDecimal().equals(new BigDecimal("-45067.444")))
failCount++;
if (!sc.nextBigDecimal().equals(new BigDecimal("3.4e10")))
failCount++;
report("BigDecimal pattern");
}
public static void integerPatternTest(int sourceType) throws Exception {
String input =
"1 22 f FF Z -3 -44 123 1,200 -123 -3,400,000 5,40 ,500 ";
Scanner sc = scannerFor(input, sourceType);
integerPatternBody(sc);
CharBuffer cb = CharBuffer.wrap(input);
sc = new Scanner(cb);
integerPatternBody(sc);
report("Integer pattern");
}
public static void integerPatternBody(Scanner sc) throws Exception {
if (sc.nextInt() != 1) failCount++;
if (sc.nextShort() != 22) failCount++;
if (sc.nextShort(16) != 15) failCount++;
if (sc.nextShort(16) != 255) failCount++;
if (sc.nextShort(36) != 35) failCount++;
if (!sc.hasNextInt()) failCount++;
if (sc.nextInt() != -3) failCount++;
if (sc.nextInt() != -44) failCount++;
if (sc.nextLong() != 123) failCount++;
if (!sc.hasNextInt()) failCount++;
if (sc.nextInt() != 1200) failCount++;
if (sc.nextInt() != -123) failCount++;
if (sc.nextInt() != -3400000) failCount++;
try {
sc.nextInt();
failCount++;
} catch (InputMismatchException ime) {
// Correct result
}
sc.next();
try {
sc.nextLong();
failCount++;
} catch (InputMismatchException ime) {
// Correct result
}
sc.next();
try {
sc.next();
failCount++;
} catch (InputMismatchException ime) {
failCount++;
} catch (NoSuchElementException nse) {
// Correct result
}
}
public static void floatPatternTest(int sourceType) throws Exception {
String input =
"090.090 1 22.0 -3 -44.05 +.123 -.1234 -3400000 56,566.6 " +
"Infinity +Infinity -Infinity NaN -NaN +NaN 5.4.0 5-.00 ++6.07";
Scanner sc = scannerFor(input, sourceType);
floatPatternBody(sc);
CharBuffer cb = CharBuffer.wrap(input);
sc = new Scanner(cb);
floatPatternBody(sc);
report("Float pattern");
}
public static void floatPatternBody(Scanner sc) throws Exception {
if (sc.nextFloat() != 090.090f) failCount++;
if (sc.nextFloat() != 1f) failCount++;
if (sc.nextFloat() != 22.0f) failCount++;
if (sc.nextDouble() != -3d) failCount++;
if (sc.nextDouble() != -44.05d) failCount++;
if (sc.nextFloat() != .123f) failCount++;
if (sc.nextFloat() != -.1234f) failCount++;
if (sc.nextDouble() != -3400000d) failCount++;
if (sc.nextDouble() != 56566.6d) failCount++;
if (sc.nextDouble() != Double.POSITIVE_INFINITY) failCount++;
if (sc.nextDouble() != Double.POSITIVE_INFINITY) failCount++;
if (sc.nextDouble() != Double.NEGATIVE_INFINITY) failCount++;
if (!Double.valueOf(sc.nextDouble()).isNaN()) failCount++;
if (!Double.valueOf(sc.nextDouble()).isNaN()) failCount++;
if (!Double.valueOf(sc.nextDouble()).isNaN()) failCount++;
try {
sc.nextFloat();
failCount++;
} catch (NoSuchElementException nse) {
// Correct result
}
try {
sc.nextDouble();
failCount++;
} catch (NoSuchElementException nse) {
// Correct result
}
try {
sc.nextDouble();
failCount++;
} catch (NoSuchElementException nse) {
// Correct result
}
}
public static void fromFileTest() throws Exception {
File f = new File(System.getProperty("test.src", "."), "input.txt");
try (Scanner sc = new Scanner(f)) {
sc.useDelimiter("\n+");
String testDataTag = sc.findWithinHorizon("fromFileTest", 0);
if (!testDataTag.equals("fromFileTest"))
failCount++;
int count = 0;
while (sc.hasNextLong()) {
long blah = sc.nextLong();
count++;
}
if (count != 7)
failCount++;
}
report("From file");
}
private static void example1() throws Exception {
Scanner s = new Scanner("1 fish 2 fish red fish blue fish");
s.useDelimiter("\\s*fish\\s*");
List <String> results = new ArrayList<String>();
while (s.hasNext())
results.add(s.next());
System.out.println(results);
}
private static void example2() throws Exception {
Scanner s = new Scanner("1 fish 2 fish red fish blue fish");
s.useDelimiter("\\s*fish\\s*");
System.out.println(s.nextInt());
System.out.println(s.nextInt());
System.out.println(s.next());
System.out.println(s.next());
}
private static void example3() throws Exception {
Scanner s = new Scanner("1 fish 2 fish red fish blue fish");
s.findInLine("(\\d+) fish (\\d+) fish (\\w+) fish (\\w+)");
for (int i=1; i<=s.match().groupCount(); i++)
System.out.println(s.match().group(i));
}
private static void findInLineTest() throws Exception {
Scanner s = new Scanner("abc def ghi jkl mno");
Pattern letters = Pattern.compile("[a-z]+");
Pattern frogs = Pattern.compile("frogs");
String str = s.findInLine(letters);
if (!str.equals("abc"))
failCount++;
if (!s.hasNext(letters))
failCount++;
try {
str = s.findInLine(frogs);
} catch (NoSuchElementException nsee) {
// Correct
}
if (!s.hasNext())
failCount++;
if (!s.hasNext(letters))
failCount++;
str = s.findInLine(letters);
if (!str.equals("def"))
failCount++;
report("Find patterns");
}
private static void findInEmptyLineTest() throws Exception {
String eol = System.getProperty("line.separator");
Scanner s = new Scanner("line 1" + eol + "" + eol + "line 3" + eol);
int lineNo = 0;
while (s.hasNextLine()) {
lineNo++;
s.findInLine("3");
s.nextLine();
}
if (lineNo != 3)
failCount++;
report("findInEmptyLine test");
}
private static void matchTest() throws Exception {
Scanner s = new Scanner("1 fish 2 fish red fish blue fish");
s.findInLine("(\\d+) fish (\\d+) fish (\\w+) fish (\\w+)");
MatchResult result = s.match();
if (!result.group(1).equals("1"))
failCount++;
if (!result.group(2).equals("2"))
failCount++;
if (!result.group(3).equals("red"))
failCount++;
if (!result.group(4).equals("blue"))
failCount++;
report("Match patterns");
}
private static void skipTest() throws Exception {
Scanner s = new Scanner("abc def ghi jkl mno");
Pattern letters = Pattern.compile("[a-z]+");
Pattern spaceLetters = Pattern.compile(" [a-z]+");
Pattern frogs = Pattern.compile("frogs");
try {
s.skip(letters);
} catch (NoSuchElementException ime) {
failCount++;
}
String token = s.next(letters);
if (!token.equals("def")) {
System.out.println("expected def");
System.out.println("I found "+token);
failCount++;
}
try {
s.skip(letters);
failCount++;
} catch (NoSuchElementException ime) {
// Correct result
}
token = s.next(letters);
if (!token.equals("ghi")) {
System.out.println("expected ghi");
System.out.println("I found "+token);
failCount++;
}
try {
s.skip(letters);
failCount++;
} catch (NoSuchElementException ime) {
// Correct result because skip ignores delims
}
try {
s.skip(spaceLetters);
} catch (NoSuchElementException ime) {
failCount++;
}
token = s.next(letters);
if (!token.equals("mno")) {
System.out.println("expected mno");
System.out.println("I found "+token);
failCount++;
}
try {
s.skip(letters);
failCount++;
} catch (NoSuchElementException ime) {
// Correct result
}
report("Skip patterns");
}
private static void byteTest(int sourceType) throws Exception {
String input = " 3 0 00 b -B 012 44 -55 12 127 129 -131 dog 0x12";
Scanner s = scannerFor(input, sourceType);
if (!s.hasNextByte()) failCount++;
if (s.nextByte() != (byte)3) failCount++;
if (!s.hasNextByte()) failCount++;
if (s.nextByte() != (byte)0) failCount++;
if (!s.hasNextByte()) failCount++;
if (s.nextByte() != (byte)0) failCount++;
if (!s.hasNextByte(16)) failCount++;
if (s.nextByte(16) != (byte)11)failCount++;
if (!s.hasNextByte(16)) failCount++;
if (s.nextByte(16) != (byte)-11) failCount++;
if (!s.hasNextByte()) failCount++;
if (s.nextByte() != (byte)12) failCount++;
if (!s.hasNextByte()) failCount++;
if (s.nextByte() != (byte)44) failCount++;
if (!s.hasNextByte()) failCount++;
if (s.nextByte() != (byte)-55) failCount++;
if (!s.hasNextByte()) failCount++;
if (s.nextByte() != (byte)12) failCount++;
if (!s.hasNextByte()) failCount++;
if (s.nextByte() != (byte)127) failCount++;
if (s.hasNextByte()) failCount++;
try {
s.nextByte();
failCount++;
} catch (InputMismatchException ime) {
// Correct result
}
if (s.hasNextByte()) failCount++;
if (s.nextInt() != 129) failCount++;
if (s.hasNextByte()) failCount++;
try {
s.nextByte();
failCount++;
} catch (InputMismatchException ime) {
// Correct result
}
if (s.nextInt() != -131) failCount++;
if (s.hasNextByte()) failCount++;
try {
s.nextByte();
failCount++;
} catch (InputMismatchException ime) {
// Correct result
}
s.next(Pattern.compile("\\w+"));
if (s.hasNextByte())
failCount++;
try {
s.nextByte();
failCount++;
} catch (NoSuchElementException nsee) {
// Correct result
}
s.next();
if (s.hasNextByte())
failCount++;
try {
byte bb = s.nextByte();
failCount++;
} catch (NoSuchElementException nsee) {
// Correct result
}
report("Scan bytes");
}
private static void shortTest(int sourceType) throws Exception {
String input = " 017 22 00E -34 44,333 -53999 0x19 dog";
Scanner s = scannerFor(input, sourceType);
if (!s.hasNextShort()) failCount++;
if (s.nextShort() != (short)17) failCount++;
if (!s.hasNextShort()) failCount++;
if (s.nextShort() != (short)22) failCount++;
if (!s.hasNextShort(16)) failCount++;
if (s.nextShort(16) != (short)14) failCount++;
if (!s.hasNextShort()) failCount++;
if (s.nextShort() != (short)-34) failCount++;
for (int i=0; i<4; i++) {
if (s.hasNextShort())
failCount++;
try {
s.nextShort();
failCount++;
} catch (InputMismatchException ime) {
// Correct result
}
s.next();
}
try {
s.next();
failCount++;
} catch (InputMismatchException ime) {
failCount++;
} catch (NoSuchElementException nse) {
// Correct result
}
report("Scan shorts");
}
private static void intTest(int sourceType) throws Exception {
Scanner s = scannerFor(
"22 022 C -34 0x80000000 -2147483649 dog ", sourceType);
if (!s.hasNextInt()) failCount++;
if (s.nextInt() != 22) failCount++;
if (!s.hasNextInt()) failCount++;
if (s.nextInt() != 22) failCount++;
if (!s.hasNextInt(16)) failCount++;
if (s.nextInt(16) != 12) failCount++;
if (!s.hasNextInt()) failCount++;
if (s.nextInt() != -34) failCount++;
for (int i=0; i<3; i++) {
if (s.hasNextInt())
failCount++;
try {
s.nextInt();
failCount++;
} catch (InputMismatchException ime) {
// Correct result
}
s.next();
}
try {
s.next();
failCount++;
} catch (InputMismatchException ime) {
failCount++;
} catch (NoSuchElementException nse) {
// Correct result
}
report("Scan ints");
}
private static void longTest(int sourceType) throws Exception {
Scanner s = scannerFor(
"022 9223372036854775807 0x8000000000000000 9223372036854775808 dog ",
sourceType);
if (!s.hasNextLong()) failCount++;
if (s.nextLong() != (long)22) failCount++;
if (!s.hasNextLong()) failCount++;
if (s.nextLong() != 9223372036854775807L) failCount++;
for (int i=0; i<3; i++) {
if (s.hasNextLong())
failCount++;
try {
s.nextLong();
failCount++;
} catch (InputMismatchException ime) {
// Correct result
}
s.next();
}
try {
s.next();
failCount++;
} catch (InputMismatchException ime) {
failCount++;
} catch (NoSuchElementException nse) {
// Correct result
}
report("Scan longs");
}
private static void floatTest(int sourceType) throws Exception {
Scanner s = scannerFor(
"0 0. 0.0 2 2. 2.0 2.3 -2 -2.0 -2.3 -. 2-. 2..3", sourceType);
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != 0f) failCount++;
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != 0f) failCount++;
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != 0f) failCount++;
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != 2f) failCount++;
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != 2f) failCount++;
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != 2f) failCount++;
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != 2.3f) failCount++;
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != -2f) failCount++;
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != -2f) failCount++;
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != -2.3f) failCount++;
for (int i=0; i<3; i++) {
if (s.hasNextLong())
failCount++;
try {
s.nextFloat();
failCount++;
} catch (InputMismatchException ime) {
// Correct result
}
s.next();
}
try {
s.next();
failCount++;
} catch (InputMismatchException ime) {
failCount++;
} catch (NoSuchElementException nse) {
// Correct result
}
report("Scan floats");
}
private static void doubleTest(int sourceType) throws Exception {
Scanner s = scannerFor(
"0 0. 0.0 2 2. 2.0 2.3 -2 -2.0 -2.3 -. 2-. 2..3", sourceType);
if (!s.hasNextDouble()) failCount++;
if (s.nextDouble() != 0d) failCount++;
if (!s.hasNextDouble()) failCount++;
if (s.nextDouble() != 0d) failCount++;
if (!s.hasNextDouble()) failCount++;
if (s.nextDouble() != 0d) failCount++;
if (!s.hasNextDouble()) failCount++;
if (s.nextDouble() != 2d) failCount++;
if (!s.hasNextDouble()) failCount++;
if (s.nextDouble() != 2d) failCount++;
if (!s.hasNextDouble()) failCount++;
if (s.nextDouble() != 2d) failCount++;
if (!s.hasNextDouble()) failCount++;
if (s.nextDouble() != 2.3d) failCount++;
if (!s.hasNextDouble()) failCount++;
if (s.nextDouble() != -2d) failCount++;
if (!s.hasNextDouble()) failCount++;
if (s.nextDouble() != -2d) failCount++;
if (!s.hasNextDouble()) failCount++;
if (s.nextDouble() != -2.3d) failCount++;
for (int i=0; i<3; i++) {
if (s.hasNextLong())
failCount++;
try {
s.nextDouble();
failCount++;
} catch (InputMismatchException ime) {
// Correct result
}
s.next();
}
try {
s.next();
failCount++;
} catch (InputMismatchException ime) {
failCount++;
} catch (NoSuchElementException nse) {
// Correct result
}
report("Scan doubles");
}
private static void booleanTest(int sourceType) throws Exception {
Scanner s = scannerFor(
" true false\t \r\n true FaLse \n True Tru", sourceType);
if (!s.nextBoolean()) failCount++;
if (!s.hasNextBoolean()) failCount++;
if (s.nextBoolean()) failCount++;
if (!s.nextBoolean()) failCount++;
if (s.nextBoolean()) failCount++;
if (!s.nextBoolean()) failCount++;
if (s.hasNextBoolean()) failCount++;
try {
s.nextBoolean();
failCount++;
} catch (NoSuchElementException nsee) {
// Expected result
}
report("Scan booleans");
}
private static void hasNextTest(int sourceType) throws Exception {
Scanner s = scannerFor(
" blah blech\t blather alongblatherindeed", sourceType);
if (!s.hasNext()) failCount++;
if (!s.hasNext()) failCount++;
String result = s.next();
if (!result.equals("blah")) failCount++;
if (!s.hasNext()) failCount++;
if (!s.hasNext()) failCount++;
result = s.next();
if (!result.equals("blech")) failCount++;
if (!s.hasNext()) failCount++;
result = s.next();
if (!result.equals("blather")) failCount++;
if (!s.hasNext()) failCount++;
if (!s.hasNext()) failCount++;
result = s.next();
if (!result.equals("alongblatherindeed")) failCount++;
if (s.hasNext()) failCount++;
try {
result = s.next();
failCount++;
} catch (NoSuchElementException nsee) {
// Correct result
}
report("Has next test");
}
private static void nextTest(int sourceType) throws Exception {
Scanner s = scannerFor(
" blah blech\t blather alongblatherindeed", sourceType);
String result = (String)s.next();
if (!result.equals("blah")) failCount++;
result = (String)s.next();
if (!result.equals("blech")) failCount++;
result = (String)s.next();
if (!result.equals("blather")) failCount++;
result = (String)s.next();
if (!result.equals("alongblatherindeed"))
failCount++;
try {
result = (String)s.next();
failCount++;
} catch (NoSuchElementException nsee) {
// Correct result
}
report("Next test");
}
private static void hasNextPatternTest(int sourceType) throws Exception {
Scanner s = scannerFor(
" blah blech\t blather alongblatherindeed", sourceType);
Pattern p1 = Pattern.compile("\\w+");
Pattern p2 = Pattern.compile("blech");
if (!s.hasNext(p1)) failCount++;
if (!s.hasNext(p1)) failCount++;
if (s.hasNext(p2)) failCount++;
String result = (String)s.next();
if (!result.equals("blah")) failCount++;
if (!s.hasNext(p1)) failCount++;
if (!s.hasNext(p2)) failCount++;
result = (String)s.next();
if (!result.equals("blech")) failCount++;
if (!s.hasNext(p1)) failCount++;
if (s.hasNext(p2)) failCount++;
result = (String)s.next();
if (!result.equals("blather")) failCount++;
if (!s.hasNext(p1)) failCount++;
if (s.hasNext(p2)) failCount++;
result = (String)s.next();
if (!result.equals("alongblatherindeed")) failCount++;
if (s.hasNext(p1)) failCount++;
if (s.hasNext(p2)) failCount++;
report("Has Next Pattern test");
}
private static void nextPatternTest(int sourceType) throws Exception {
Scanner s = scannerFor(
" blah blech\t blather alongblatherindeed", sourceType);
Pattern p1 = Pattern.compile("blah");
Pattern p2 = Pattern.compile("blech");
Pattern p3 = Pattern.compile("blather");
Pattern p4 = Pattern.compile("alongblatherindeed");
String result = null;
try {
result = (String)s.next(p2);
failCount++;
} catch (NoSuchElementException nsee) {
// Correct result
}
result = (String)s.next(p1);
if (!result.equals("blah"))
failCount++;
try {
result = (String)s.next(p1);
failCount++;
} catch (NoSuchElementException nsee) {
// Correct result
}
result = (String)s.next(p2);
if (!result.equals("blech"))
failCount++;
try {
result = (String)s.next(p4);
failCount++;
} catch (NoSuchElementException nsee) {
// Correct result
}
result = (String)s.next(p3);
if (!result.equals("blather"))
failCount++;
try {
result = (String)s.next(p3);
failCount++;
} catch (NoSuchElementException nsee) {
// Correct result
}
result = (String)s.next(p4);
if (!result.equals("alongblatherindeed"))
failCount++;
try {
result = (String)s.next();
failCount++;
} catch (NoSuchElementException nsee) {
// Correct result
}
report("Next pattern test");
}
private static void useLocaleTest() throws Exception {
Scanner s = new Scanner("334.65").useLocale(Locale.ENGLISH);
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != 334.65f) failCount++;
s = new Scanner("334,65").useLocale(Locale.FRENCH);
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != 334.65f) failCount++;
s = new Scanner("4.334,65").useLocale(Locale.GERMAN);
if (!s.hasNextFloat()) failCount++;
if (s.nextFloat() != 4334.65f) failCount++;
// Test case reported from India
try {
String Message = "123978.90 $";
Locale locale = new Locale("hi","IN");
NumberFormat form = NumberFormat.getInstance(locale);
double myNumber = 1902.09;
Scanner scanner = new Scanner(form.format(myNumber).toString());
scanner.useLocale(locale);
double d = scanner.nextDouble();
} catch (InputMismatchException ime) {
failCount++;
}
report("Use locale test");
}
public static void resetTest() throws Exception {
Scanner sc = new Scanner("");
int radix = sc.radix();
Locale locale = sc.locale();
Pattern delimiter = sc.delimiter();
Pattern a = Pattern.compile("A");
sc.useDelimiter(a);
Locale dummy = new Locale("en", "US", "dummy");
sc.useLocale(dummy);
sc.useRadix(16);
if (sc.radix() != 16 ||
!sc.locale().equals(dummy) ||
!sc.delimiter().pattern().equals(a.pattern())) {
failCount++;
} else {
sc.reset();
if (sc.radix() != radix ||
!sc.locale().equals(locale) ||
!sc.delimiter().pattern().equals(delimiter.pattern())) {
failCount++;
}
}
sc.close();
report("Reset test");
}
static List<BiConsumer <Scanner, Integer>> methodWRList = Arrays.asList(
(s, r) -> s.hasNextByte(r),
(s, r) -> s.nextByte(r),
(s, r) -> s.hasNextShort(r),
(s, r) -> s.nextShort(r),
(s, r) -> s.hasNextInt(r),
(s, r) -> s.nextInt(r),
(s, r) -> s.hasNextLong(r),
(s, r) -> s.nextLong(r),
(s, r) -> s.hasNextBigInteger(r),
(s, r) -> s.nextBigInteger(r)
);
/*
* Test that setting the radix to an out of range value triggers
* an IllegalArgumentException
*/
public static void outOfRangeRadixTest() throws Exception {
int[] bad = new int[] { -1, 0, 1, 37, 38 };
int[] good = IntStream.rangeClosed(Character.MIN_RADIX, Character.MAX_RADIX)
.toArray();
methodWRList.stream().forEach( m -> {
for (int r : bad) {
try (Scanner sc = new Scanner("10 10 10 10")) {
m.accept(sc, r);
failCount++;
} catch (IllegalArgumentException ise) {}
}
});
methodWRList.stream().forEach( m -> {
for (int r : good) {
try (Scanner sc = new Scanner("10 10 10 10")) {
m.accept(sc, r);
} catch (Exception x) {
failCount++;
}
}
});
report("Radix out of range test");
}
/*
* Test that closing the stream also closes the underlying Scanner.
* The cases of attempting to open streams on a closed Scanner are
* covered by closeTest().
*/
public static void streamCloseTest() throws Exception {
Scanner sc;
Scanner sc1 = new Scanner("xyzzy");
sc1.tokens().close();
try {
sc1.hasNext();
failCount++;
} catch (IllegalStateException ise) {
// Correct result
}
Scanner sc2 = new Scanner("a b c d e f");
try {
sc2.tokens()
.peek(s -> sc2.close())
.count();
} catch (IllegalStateException ise) {
// Correct result
}
Scanner sc3 = new Scanner("xyzzy");
sc3.findAll("q").close();
try {
sc3.hasNext();
failCount++;
} catch (IllegalStateException ise) {
// Correct result
}
try (Scanner sc4 = new Scanner(inputFile)) {
sc4.findAll("[0-9]+")
.peek(s -> sc4.close())
.count();
failCount++;
} catch (IllegalStateException ise) {
// Correct result
}
report("Streams Close test");
}
/*
* Test ConcurrentModificationException
*/
public static void streamComodTest() {
try {
Scanner sc = new Scanner("a b c d e f");
sc.tokens()
.peek(s -> sc.hasNext())
.count();
failCount++;
} catch (ConcurrentModificationException cme) {
// Correct result
}
try {
Scanner sc = new Scanner("a b c d e f");
Iterator<String> it = sc.tokens().iterator();
it.next();
sc.next();
it.next();
failCount++;
} catch (ConcurrentModificationException cme) {
// Correct result
}
try {
String input = IntStream.range(0, 100)
.mapToObj(String::valueOf)
.collect(Collectors.joining(" "));
Scanner sc = new Scanner(input);
sc.findAll("[0-9]+")
.peek(s -> sc.hasNext())
.count();
failCount++;
} catch (ConcurrentModificationException cme) {
// Correct result
}
try {
String input = IntStream.range(0, 100)
.mapToObj(String::valueOf)
.collect(Collectors.joining(" "));
Scanner sc = new Scanner(input);
Iterator<MatchResult> it = sc.findAll("[0-9]+").iterator();
it.next();
sc.next();
it.next();
failCount++;
} catch (ConcurrentModificationException cme) {
// Correct result
}
report("Streams Comod test");
}
private static void report(String testName) {
System.err.printf("%-30s: %s%n", testName,
(failCount == 0) ? "Passed" : String.format("Failed(%d)", failCount));
if (failCount > 0)
failure = true;
failCount = 0;
}
static Scanner scannerFor(String input, int sourceType) {
if (sourceType == 1)
return new Scanner(input);
else
return new Scanner(new StutteringInputStream(input));
}
static class ThrowingReadable implements Readable {
ThrowingReadable() {
}
public int read(java.nio.CharBuffer cb) throws IOException {
throw new IOException("ThrowingReadable always throws");
}
}
}