| /* | |
| * Copyright (c) 2003, 2022, 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 8172695 | |
| * @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 defaultLocale = Locale.getDefault(); | |
| try { | |
| // Before we have resource to improve the test to be ready for | |
| // arbitrary locale, force the default locale to be ROOT for now. | |
| Locale.setDefault(Locale.US); | |
| 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(defaultLocale); | |
| } | |
| } | |
| 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 = Locale.of("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 = Locale.of("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"); | |
| } | |
| } | |
| } |