Quelle  ScanTest.java   Sprache: JAVA

", "

", "
• " };
              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");
          }
      }
  }