android-12.0.0_r34/s

/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.harmony.tests.java.util;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.StringReader;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.nio.CharBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.IllegalBlockingModeException;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Locale;
import java.util.NoSuchElementException;
import java.util.Scanner;
import java.util.regex.MatchResult;
import java.util.regex.Pattern;
import junit.framework.TestCase;

public class ScannerTest extends TestCase {

    private Scanner s;

    private ServerSocket server;

    private SocketAddress address;

    private SocketChannel client;

    private Socket serverSocket;

    private OutputStream os;

    private static class MockCloseable implements Closeable, Readable {

        public void close() throws IOException {
            throw new IOException();
        }

        public int read(CharBuffer cb) throws IOException {
            throw new EOFException();
        }

    }

    /**
     * @tests java.util.Scanner#Scanner(File)
     */
    public void test_ConstructorLjava_io_File() throws IOException {
        File tmpFile = File.createTempFile("TestFileForScanner", ".tmp");
        s = new Scanner(tmpFile);
        assertNotNull(s);
        s.close();
        assertTrue(tmpFile.delete());

        try {
            s = new Scanner(tmpFile);
            fail();
        } catch (FileNotFoundException expected) {
        }

        tmpFile = File.createTempFile("TestFileForScanner", ".tmp");
        FileOutputStream fos = new FileOutputStream(tmpFile);
        fos.write("test".getBytes());
        fos.close();

        s = new Scanner(tmpFile);
        s.close();
        tmpFile.delete();

        // Scanner(File = null)
        try {
            s = new Scanner((File) null);
            fail();
        } catch (NullPointerException expected) {
        }

        // TODO: test if the default charset is used.
    }


    /**
     * @tests java.util.Scanner#Scanner(Path)
     */
    public void test_ConstructorLjava_nio_file_Path() throws IOException {
        Path tmpFilePath = Files.createTempFile("TestFileForScanner", ".tmp");
        String testString = "test";
        try (OutputStream os = Files.newOutputStream(tmpFilePath)) {
            os.write(testString.getBytes());
        }
        try (Scanner s = new Scanner(tmpFilePath)){
            assertEquals(testString, s.next());
            assertFalse(s.hasNext());
        }
    }

    /**
     * @tests java.util.Scanner#Scanner(Path)
     */
    public void test_ConstructorLjava_nio_file_Path_Exception() throws IOException {
        Path nonExistentFilePath = Paths.get("testPath");
        try (Scanner s = new Scanner(nonExistentFilePath)) {
            fail();
        } catch (NoSuchFileException expected) {
        }

        try (Scanner s = new Scanner((Path) null)) {
            fail();
        } catch (NullPointerException expected) {
        }
    }

    /**
     * @tests java.util.Scanner#Scanner(File, String)
     */
    public void test_ConstructorLjava_io_FileLjava_lang_String()
            throws IOException {
        File tmpFile = File.createTempFile("TestFileForScanner", ".tmp");
        s = new Scanner(tmpFile, Charset.defaultCharset().name());
        assertNotNull(s);
        s.close();
        assertTrue(tmpFile.delete());

        try {
            s = new Scanner(tmpFile, Charset.defaultCharset().name());
            fail();
        } catch (FileNotFoundException expected) {
        }

        // Bogus test : Depends on the order in which expections are thrown.
        try {
            s = new Scanner(tmpFile, null);
            fail();
        } catch (IllegalArgumentException expected) {
        }

        tmpFile = File.createTempFile("TestFileForScanner", ".tmp");
        try {
            s = new Scanner(tmpFile, "invalid charset");
            fail();
        } catch (IllegalArgumentException expected) {
        }

        //fail on RI. File is opened but not closed when exception is thrown on
        // RI.
        assertTrue(tmpFile.delete());

        // Scanner(File = null, Charset = null)
        try {
            s = new Scanner((File) null, null);
            fail();
        } catch (NullPointerException expected) {
        }

        // Scanner(File = null, Charset = UTF-8)
        try {
            s = new Scanner((File) null, "UTF-8");
            fail();
        } catch (NullPointerException expected) {
        }

        // Scanner(File = null, Charset = invalid)
        try {
            s = new Scanner((File) null, "invalid");
            fail();
        } catch (NullPointerException expected) {
        }

        // Scanner(File, Charset = null)
        try {
            File f = File.createTempFile("test", ".tmp");
            s = new Scanner(f, null);
            fail();
        } catch (IllegalArgumentException expected) {
        }

        // TODO: test if the specified charset is used.
    }

    /**
     * @tests java.util.Scanner#Scanner(Path, String)
     */
    public void test_ConstructorLjava_nio_file_PathLjava_lang_String()
            throws IOException {
        Path tmpFilePath = Files.createTempFile("TestFileForScanner", ".tmp");
        String testString = "परीक्षण";
        try (OutputStream os = Files.newOutputStream(tmpFilePath)) {
            os.write(testString.getBytes());
        }
        // With correct charset.
        try (Scanner s = new Scanner(tmpFilePath, Charset.defaultCharset().name())){
            assertEquals(testString, s.next());
            assertFalse(s.hasNext());
        }
        // With incorrect charset.
        try (Scanner s = new Scanner(tmpFilePath, "US-ASCII")){
            if (s.next().equals(testString)) {
                fail("Should not be able to read with incorrect charset.");
            }
        }
    }

    /**
     * @tests java.util.Scanner#Scanner(Path, String)
     */
    public void test_ConstructorLjava_nio_file_PathLjava_lang_String_Exception()
            throws IOException {
        Path nonExistentFilePath = Paths.get("nonExistentFile");
        Path existentFilePath = Files.createTempFile("TestFileForScanner", ".tmp");

        // File doesn't exist.
        try (Scanner s = new Scanner(nonExistentFilePath, Charset.defaultCharset().name())) {
            fail();
        } catch (NoSuchFileException expected) {
        }

        // Exception order test.
        try {
            s = new Scanner(nonExistentFilePath, null);
            fail();
        } catch (NullPointerException expected) {
        }

        // Invalid charset.
        try {
            s = new Scanner(existentFilePath, "invalid charset");
            fail();
        } catch (IllegalArgumentException expected) {
        }

        // Scanner(Path = null, Charset = null)
        try (Scanner s = new Scanner((Path) null, null)) {
            fail();
        } catch (NullPointerException expected) {
        }

        // Scanner(Path = null, Charset = UTF-8)
        try (Scanner s = new Scanner((Path) null, "UTF-8")) {
            fail();
        } catch (NullPointerException expected) {
        }

        // Scanner(Path = null, Charset = invalid)
        try (Scanner s = new Scanner((Path) null, "invalid")) {
            fail();
        } catch (NullPointerException expected) {
        }

        // Scanner(Path, Charset = null)
        try (Scanner s = new Scanner(existentFilePath, null)) {
            fail();
        } catch (NullPointerException expected) {
        }
    }


    /**
     * @tests java.util.Scanner#Scanner(InputStream)
     */
    public void test_ConstructorLjava_io_InputStream() {
        s = new Scanner(new PipedInputStream());
        assertNotNull(s);
        s.close();

        // Scanner(InputStream)
        try {
            s = new Scanner((InputStream) null);
            fail();
        } catch (NullPointerException expected) {
        }

        // TODO: test if the default charset is used.
    }

    /**
     * @tests java.util.Scanner#Scanner(InputStream, String)
     */
    public void test_ConstructorLjava_io_InputStreamLjava_lang_String() {
        s = new Scanner(new PipedInputStream(), Charset.defaultCharset().name());
        assertNotNull(s);
        s.close();

        try {
            s = new Scanner((PipedInputStream) null, "invalid charset");
            fail();
        } catch (NullPointerException expected) {
        }

        try {
            s = new Scanner(new PipedInputStream(), null);
            fail();
        } catch (NullPointerException expected) {
        }

        try {
            s = new Scanner(new PipedInputStream(), "invalid charset");
            fail();
        } catch (IllegalArgumentException expected) {
        }

        // TODO: test if the specified charset is used.
    }

    /**
     * @tests java.util.Scanner#Scanner(Readable)
     */
    public void test_ConstructorLjava_lang_Readable() {
        s = new Scanner(new StringReader("test string"));
        assertNotNull(s);
        s.close();

        // Scanner(Readable)
        try {
            s = new Scanner((Readable) null);
            fail();
        } catch (NullPointerException expected) {
        }
    }

    /**
     * @tests java.util.Scanner#Scanner(ReadableByteChannel)
     */
    public void test_ConstructorLjava_nio_channels_ReadableByteChannel()
            throws IOException {
        File tmpFile = File.createTempFile("TestFileForScanner", ".tmp");
        FileChannel fc = new FileOutputStream(tmpFile).getChannel();
        s = new Scanner(fc);
        assertNotNull(s);
        s.close();
        assertTrue(tmpFile.delete());

        // Scanner(ReadableByteChannel)
        try {
            s = new Scanner((ReadableByteChannel) null);
            fail();
        } catch (NullPointerException expected) {
        }

        // Test if the default charset is used.
        String sampleData = "1 2 3 4 5 6 7 8 9 10";
        File tempFile = File.createTempFile("harmony", "test");
        tempFile.deleteOnExit();
        FileOutputStream os = new FileOutputStream(tempFile);
        os.write(sampleData.getBytes());
        os.close();

        FileInputStream is = new FileInputStream(tempFile);
        FileChannel channel = is.getChannel();

        Scanner s = new Scanner(channel);
        int count = 0;
        while (s.hasNextInt()) {
            s.nextInt();
            count++;
        }
        channel.close();
        assertEquals(10, count);
    }

    /**
     * @tests java.util.Scanner#Scanner(ReadableByteChannel, String)
     */
    public void test_ConstructorLjava_nio_channels_ReadableByteChannelLjava_lang_String()
            throws IOException {
        File tmpFile = File.createTempFile("TestFileForScanner", ".tmp");
        FileChannel fc = new FileOutputStream(tmpFile).getChannel();
        s = new Scanner(fc, Charset.defaultCharset().name());
        assertNotNull(s);
        s.close();

        fc = new FileOutputStream(tmpFile).getChannel();
        try {
            s = new Scanner(fc, "invalid charset");
            fail();
        } catch (IllegalArgumentException expected) {
        }
        fc.close();
        assertTrue(tmpFile.delete());

        // Scanner(ReadableByteChannel = null, Charset = null)
        try {
            s = new Scanner((ReadableByteChannel) null, null);
            fail();
        } catch (NullPointerException expected) {
        }

        // Scanner(ReadableByteChannel = null, Charset = invalid)
        try {
            s = new Scanner((ReadableByteChannel) null, "invalid");
            fail();
        } catch (NullPointerException expected) {
        }

        // Scanner(ReadableByteChannel, Charset = null)
        try {
            s = new Scanner(fc, null);
            fail();
        } catch (IllegalArgumentException expected) {
        }
        // TODO: test if the specified charset is used.
    }

    public void test_Constructor_LReadableByteChannel() throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.socket().bind(null);

        SocketChannel sc = SocketChannel.open();
        sc.connect(ssc.socket().getLocalSocketAddress());
        sc.configureBlocking(false);
        assertFalse(sc.isBlocking());

        ssc.accept().close();
        ssc.close();
        assertFalse(sc.isBlocking());

        Scanner s = new Scanner(sc);
        try {
            s.hasNextInt();
            fail();
        } catch (IllegalBlockingModeException expected) {
        }

        sc.close();
    }

    /**
     * @tests java.util.Scanner#Scanner(String)
     */
    public void test_ConstructorLjava_lang_String() {
        s = new Scanner("test string");
        assertNotNull(s);
        s.close();

        // Scanner(String)
        try {
            s = new Scanner((String) null);
            fail();
        } catch (NullPointerException expected) {
        }
    }

    /**
     * @tests java.util.Scanner#close()
     */
    public void test_close() throws IOException {
        File tmpFile = File.createTempFile("TestFileForScanner", ".tmp");
        FileOutputStream fos = new FileOutputStream(tmpFile);
        FileChannel fc = fos.getChannel();
        s = new Scanner(fc);

        // Write out a int before the scanner is closed, should be OK.
        fos.write(12);

        s.close();
        assertFalse(fc.isOpen());

        // Write out a int after the scanner is closed, IOException should be
        // thrown out.
        try {
            fos.write(12);
            fail();
        } catch (IOException expected) {
        }

        s.close(); // no exception should be thrown
        assertTrue(tmpFile.delete());
    }

    /**
     * @tests java.util.Scanner#ioException()
     */
    public void test_ioException() throws IOException {
        MockCloseable mc = new MockCloseable();
        s = new Scanner(mc);
        assertNull(s.ioException()); // No operation, no exception

        s.close(); // IOException should be cached
        assertNotNull(s.ioException());
        assertTrue(s.ioException() instanceof IOException);
    }

    /**
     * @tests java.util.Scanner#delimiter()
     */
    public void test_delimiter() {
        s = new Scanner("test");
        Pattern pattern = s.delimiter();
        assertEquals("\\p{javaWhitespace}+", pattern.toString());
    }

    /**
     * @tests java.util.Scanner#useDelimiter(Pattern)
     */
    public void test_useDelimiter_LPattern() {
        s = new Scanner("test");
        s.useDelimiter(Pattern.compile("\\w+"));
        assertEquals("\\w+", s.delimiter().toString());

        s = new Scanner("test");
        s.useDelimiter((Pattern) null);
        assertNull(s.delimiter());
    }

    /**
     * @tests java.util.Scanner#useDelimiter(String)
     */
    public void test_useDelimiter_String() {
        s = new Scanner("test");
        try {
            s.useDelimiter((String) null);
            fail();
        } catch (NullPointerException expected) {
        }

        s = new Scanner("test");
        s.useDelimiter("\\w+");
        assertEquals("\\w+", s.delimiter().toString());
    }

    /**
     * @tests java.util.Scanner#locale()
     */
    public void test_locale() {
        s = new Scanner("test");
        assertEquals(Locale.getDefault(), s.locale());
    }

    /**
     * @tests java.util.Scanner#useLocale(Locale)
     */
    public void test_useLocale_LLocale() {
        s = new Scanner("test");
        try {
            s.useLocale(null);
            fail();
        } catch (NullPointerException expected) {
        }

        s.useLocale(new Locale("test", "test"));
        assertEquals(new Locale("test", "test"), s.locale());
    }

    /**
     * @tests java.util.Scanner#radix()
     */
    public void test_radix() {
        s = new Scanner("test");
        assertEquals(10, s.radix());
    }

    /**
     * @tests java.util.Scanner#useRadix()
     */
    public void test_useRadix_I() {
        s = new Scanner("test");
        try {
            s.useRadix(Character.MIN_RADIX - 1);
            fail();
        } catch (IllegalArgumentException expected) {
        }
        try {
            s.useRadix(Character.MAX_RADIX + 1);
            fail();
        } catch (IllegalArgumentException expected) {
        }
        s.useRadix(11);
        assertEquals(11, s.radix());
    }

    /**
     * @tests java.util.Scanner#remove()
     */
    public void test_remove() {
        s = new Scanner("aab*b*").useDelimiter("\\*");
        try {
            s.remove();
            fail();
        } catch (UnsupportedOperationException expected) {
        }
    }

    /**
     * @tests java.util.Scanner#match()
     */
    public void test_match() {
        MatchResult result ;
        s = new Scanner("1 2 ");
        try {
            s.match();
            fail();
        } catch (IllegalStateException expected) {
        }
        assertEquals("1", s.next());
        assertEquals("2", s.next());
        result = s.match();
        assertEquals(2, result.start());
        assertEquals(3, result.end());
        assertEquals(2, result.start(0));
        assertEquals(3, result.end(0));
        assertEquals("2", result.group());
        assertEquals("2", result.group(0));
        assertEquals(0, result.groupCount());
        try {
            result.start(1);
            fail();
        } catch (IndexOutOfBoundsException expected) {
        }
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }
        try {
            s.match();
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("True faLse");
        try {
            s.match();
            fail();
        } catch (IllegalStateException expected) {
        }
        assertTrue(s.nextBoolean());
        result = s.match();
        assertEquals(0, result.start());
        assertEquals(4, result.end());
        assertEquals(0, result.start(0));
        assertEquals(4, result.end(0));
        assertEquals("True", result.group());
        assertEquals(0, result.groupCount());
        assertFalse(s.nextBoolean());
        try {
            s.nextBoolean();
            fail();
        } catch (NoSuchElementException expected) {
        }
        try {
            s.match();
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("True faLse");
        assertTrue(s.nextBoolean());
        result = s.match();
        assertEquals(0, result.start());
        assertEquals(4, result.end());
        assertEquals(0, result.start(0));
        assertEquals(4, result.end(0));
        assertEquals("True", result.group());
        assertEquals(0, result.groupCount());
        s.close();
        try {
            s.nextBoolean();
            fail();
        } catch (IllegalStateException expected) {
        }
        result = s.match();
        assertEquals(0, result.start());
        assertEquals(4, result.end());
        assertEquals(0, result.start(0));
        assertEquals(4, result.end(0));
        assertEquals("True", result.group());
        assertEquals(0, result.groupCount());

        s = new Scanner("True fase");
        assertTrue(s.nextBoolean());
        assertEquals(0, result.groupCount());
        try {
            s.nextBoolean();
            fail();
        } catch (InputMismatchException expected) {
        }
        try {
            s.match();
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("True fase");
        assertTrue(s.nextBoolean());
        try {
            s.next((Pattern)null);
            fail();
        } catch (NullPointerException expected) {
        }
        result = s.match();
        assertEquals(0, result.start());
        assertEquals(4, result.end());
        assertEquals(0, result.start(0));
        assertEquals(4, result.end(0));
        assertEquals("True", result.group());
        assertEquals(0, result.groupCount());

    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#next()
     */
    public void test_next() throws IOException {
        // use special delimiter
        s = new Scanner("1**2").useDelimiter("\\*");
        assertEquals("1", s.next());
        assertEquals("", s.next());
        assertEquals("2", s.next());

        s = new Scanner(" \t 1 \t 2").useDelimiter("\\s*");
        assertEquals("1", s.next());
        assertEquals("2", s.next());
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("a").useDelimiter("a?");
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("aa").useDelimiter("a?");
        assertEquals("", s.next());
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }


        s = new Scanner("word( )test( )").useDelimiter("\\( \\)");
        assertEquals("word", s.next());
        assertEquals("test", s.next());

        s = new Scanner("? next  ").useDelimiter("( )");
        assertEquals("?", s.next());
        assertEquals("next", s.next());
        assertEquals("", s.next());

        s = new Scanner("word1 word2  ");
        assertEquals("word1", s.next());
        assertEquals("word2", s.next());
        // test boundary case
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // just delimiter exists in this scanner
        s = new Scanner(" ");
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // nothing exists in this scanner
        s = new Scanner("");
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // no delimiter exists in this scanner
        s = new Scanner("test");
        assertEquals("test", s.next());

        // input resourse starts with delimiter
        s = new Scanner("  test");
        assertEquals("test", s.next());

        // input resource ends with delimiter
        s = new Scanner("  test  ");
        assertEquals("test", s.next());

        // Harmony uses 1024 as default buffer size,
        // What if a sentence can not be read in all in once.
        StringBuilder longSentence = new StringBuilder(1025);
        for (int i = 0; i < 11; i++) {
            longSentence.append(" ");
        }
        for (int i = 11; i < 1026; i++) {
            longSentence.append("a");
        }
        s = new Scanner(longSentence.toString());
        assertEquals(longSentence.toString().trim(), s.next());

        s = new Scanner(" test test");
        assertEquals("test", s.next());
        assertEquals("test", s.next());

        // What if use a delimiter of length 0.
        s = new Scanner("test\ntest").useDelimiter(Pattern.compile("^",
                Pattern.MULTILINE));
        assertEquals("test\n", s.next());
        assertEquals("test", s.next());

        s = new Scanner("").useDelimiter(Pattern.compile("^",
                Pattern.MULTILINE));
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("").useDelimiter(Pattern.compile("^*",
                Pattern.MULTILINE));
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("test\ntest").useDelimiter(Pattern.compile("^*",
                Pattern.MULTILINE));
        assertEquals("t", s.next());
        assertEquals("e", s.next());

        s = new Scanner("\ntest\ntest").useDelimiter(Pattern.compile("$",
                Pattern.MULTILINE));
        assertEquals("\ntest", s.next());
        assertEquals("\ntest", s.next());

        // test socket inputStream
        // Harmony uses 1024 as default buffer size,
        // what if the leading delimiter is larger than 1023
        for (int i = 0; i < 1024; i++) {
            os.write(" ".getBytes());
        }
        os.write("  1 2 ".getBytes());
        s = new Scanner(client);
        assertEquals("1", s.next());
        assertEquals("2", s.next());
        os.write("  1 2".getBytes());
        serverSocket.close();
        assertEquals("1", s.next());
        assertEquals("2", s.next());
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }

    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#next(Pattern)
     */
    public void test_nextLPattern() throws IOException {
        Pattern pattern;
        s = new Scanner("aab*2*").useDelimiter("\\*");
        pattern = Pattern.compile("a*b");
        assertEquals("aab", s.next(pattern));
        try {
            s.next(pattern);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("word ? ");
        pattern = Pattern.compile("\\w+");
        assertEquals("word", s.next(pattern));
        try {
            s.next(pattern);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("word1 word2  ");
        pattern = Pattern.compile("\\w+");
        assertEquals("word1", s.next(pattern));
        assertEquals("word2", s.next(pattern));
        // test boundary case
        try {
            s.next(pattern);
            fail();
        } catch (NoSuchElementException expected) {
        }

        // test socket inputStream

        os.write("aab 2".getBytes());
        serverSocket.close();

        s = new Scanner(client);
        pattern = Pattern.compile("a*b");
        assertEquals("aab", s.next(pattern));
        try {
            s.next(pattern);
            fail();
        } catch (InputMismatchException expected) {
        }
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#next(String)
     */
    public void test_nextLString() throws IOException {
        s = new Scanner("b*a*").useDelimiter("\\*");
        assertEquals("b", s.next("a*b"));
        try {
            s.next("a*b");
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("word ? ");
        assertEquals("word", s.next("\\w+"));
        try {
            s.next("\\w+");
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("word1 next  ");
        assertEquals("word1", s.next("\\w+"));
        assertEquals("next", s.next("\\w+"));
        // test boundary case
        try {
            s.next("\\w+");
            fail();
        } catch (NoSuchElementException expected) {
        }

        // test socket inputStream
        os.write("aab 2".getBytes());
        serverSocket.close();

        s = new Scanner(client);
        assertEquals("aab", s.next("a*b"));
        try {
            s.next("a*b");
            fail();
        } catch (InputMismatchException expected) {
        }
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextBoolean()
     */
    public void test_nextBoolean() throws IOException {
        // case insensitive
        s = new Scanner("TRue");
        assertTrue(s.nextBoolean());

        s = new Scanner("tRue false");
        assertTrue(s.nextBoolean());
        assertFalse(s.nextBoolean());
        try {
            s.nextBoolean();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("true1");
        try {
            s.nextBoolean();
            fail();
        } catch (InputMismatchException expected) {
        }

        try {
            s = new Scanner("");
            s.nextBoolean();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // test socket inputStream
        os.write("true false".getBytes());
        serverSocket.close();

        s = new Scanner(client);
        assertTrue(s.nextBoolean());
        assertFalse(s.nextBoolean());

        // ues '*' as delimiter
        s = new Scanner("true**false").useDelimiter("\\*");
        assertTrue(s.nextBoolean());
        try {
            s.nextBoolean();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("false( )").useDelimiter("\\( \\)");
        assertFalse(s.nextBoolean());

    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextInt(int)
     */
    public void test_nextIntI() throws IOException {
        s = new Scanner("123 456");
        assertEquals(123, s.nextInt(10));
        assertEquals(456, s.nextInt(10));
        try {
            s.nextInt(10);
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        assertEquals(38, s.nextInt(5));
        try {
            s.nextInt(5);
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("123456789123456789123456789123456789");
        try {
            s.nextInt(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextInt(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextInt(10));
        assertEquals(23456, s.nextInt(10));

        /*
         * '’' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextInt(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextInt(10));
        assertEquals(23456, s.nextInt(10));

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertEquals(102, s.nextInt(10));
        try {
            s.nextInt(5);
            fail();
        } catch (InputMismatchException expected) {
        }
        assertEquals(162, s.nextInt(10));

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        try {
            s.nextInt(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextInt(10));
        assertEquals(23456, s.nextInt(10));

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        try {
            s.nextInt(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertEquals(3456, s.nextInt(10));

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(3456, s.nextInt(10));

        s = new Scanner("E3456");
        assertEquals(930902, s.nextInt(16));
        // The following test case fails on RI, because RI does not support
        // letter as leading digit
        s = new Scanner("E3,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(930902, s.nextInt(16));

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextInt(10));

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextInt(10));

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextInt(10));

        s = new Scanner("-123 123-");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(-123, s.nextInt());
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("-123 -123-");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(-123, s.nextInt());
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("-123 123-");
        s.useLocale(new Locale("mk", "MK"));
        assertEquals(-123, s.nextInt(10));
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }
        // Skip the un-recognizable token 123-.
        assertEquals("123-", s.next());

        // If the parameter radix is illegal, the following test cases fail on
        // RI
        try {
            s.nextInt(Character.MIN_RADIX - 1);
            fail();
        } catch (IllegalArgumentException expected) {
        }
        try {
            s.nextInt(Character.MAX_RADIX + 1);
            fail();
        } catch (IllegalArgumentException expected) {
        }
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextInt()
     */
    public void test_nextInt() throws IOException {
        s = new Scanner("123 456");
        assertEquals(123, s.nextInt());
        assertEquals(456, s.nextInt());
        try {
            s.nextInt();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        s.useRadix(5);
        assertEquals(38, s.nextInt());
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("123456789123456789123456789123456789");
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextInt());
        assertEquals(23456, s.nextInt());

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextInt());
        assertEquals(23456, s.nextInt());

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertEquals(102, s.nextInt());
        s.useRadix(5);
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useRadix(10);
        assertEquals(162, s.nextInt());

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextInt());
        assertEquals(23456, s.nextInt());

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertEquals(3456, s.nextInt());

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(3456, s.nextInt());

        s = new Scanner("E3456");
        s.useRadix(16);
        assertEquals(930902, s.nextInt());

        // The following test case fails on RI, because RI does not support
        // letter as leading digit
        s = new Scanner("E3,456");
        s.useLocale(Locale.ENGLISH);
        s.useRadix(16);
        assertEquals(930902, s.nextInt());

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextInt());

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextInt());

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextInt());

        s = new Scanner("-123 123-");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(-123, s.nextInt());
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("-123 -123-");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(-123, s.nextInt());
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("-123 123-");
        s.useLocale(new Locale("mk", "MK"));
        assertEquals(-123, s.nextInt());
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }
        // Skip the un-recognizable token 123-.
        assertEquals("123-", s.next());
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextByte(int)
     */
    public void test_nextByteI() throws IOException {
        s = new Scanner("123 126");
        assertEquals(123, s.nextByte(10));
        assertEquals(126, s.nextByte(10));
        try {
            s.nextByte(10);
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 126");
        assertEquals(38, s.nextByte(5));
        try {
            s.nextByte(5);
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("1234");
        try {
            s.nextByte(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 12\u0666");
        assertEquals(102, s.nextByte(10));
        try {
            s.nextByte(5);
            fail();
        } catch (InputMismatchException expected) {
        }
        assertEquals(126, s.nextByte(10));

        s = new Scanner("012");
        assertEquals(12, s.nextByte(10));

        s = new Scanner("E");
        assertEquals(14, s.nextByte(16));

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("100");
        s.useLocale(Locale.CHINESE);
        assertEquals(100, s.nextByte(10));

        s = new Scanner("1\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertEquals(100, s.nextByte(10));

        s = new Scanner("1\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertEquals(100, s.nextByte(10));

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(-123, s.nextByte(10));


        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertEquals(-123, s.nextByte(10));
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextByte()
     */
    public void test_nextByte() throws IOException {
        s = new Scanner("123 126");
        assertEquals(123, s.nextByte());
        assertEquals(126, s.nextByte());
        try {
            s.nextByte();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 126");
        s.useRadix(5);
        assertEquals(38, s.nextByte());
        try {
            s.nextByte();
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("1234");
        try {
            s.nextByte();
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 12\u0666");
        assertEquals(102, s.nextByte());
        s.useRadix(5);
        try {
            s.nextByte();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useRadix(10);
        assertEquals(126, s.nextByte());

        s = new Scanner("012");
        assertEquals(12, s.nextByte());

        s = new Scanner("E");
        s.useRadix(16);
        assertEquals(14, s.nextByte());

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("100");
        s.useLocale(Locale.CHINESE);
        assertEquals(100, s.nextByte());

        s = new Scanner("1\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertEquals(100, s.nextByte());

        s = new Scanner("1\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertEquals(100, s.nextByte());

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(-123, s.nextByte());

        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertEquals(-123, s.nextByte());
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextFloat()
     */
    public void test_nextFloat() throws IOException {
        s = new Scanner("123 45\u0666. 123.4 .123 ");
        s.useLocale(Locale.ENGLISH);
        assertEquals((float)123.0, s.nextFloat());
        assertEquals((float)456.0, s.nextFloat());
        assertEquals((float)123.4, s.nextFloat());
        assertEquals((float)0.123, s.nextFloat());
        try {
            s.nextFloat();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("+123.4 -456.7 123,456.789 0.1\u06623,4");
        s.useLocale(Locale.ENGLISH);
        assertEquals((float)123.4, s.nextFloat());
        assertEquals((float)-456.7, s.nextFloat());
        assertEquals((float)123456.789, s.nextFloat());
        try {
            s.nextFloat();
            fail();
        } catch (InputMismatchException expected) {
        }

        // Scientific notation
        s = new Scanner("+123.4E10 -456.7e+12 123,456.789E-10");
        s.useLocale(Locale.ENGLISH);
        assertEquals((float)1.234E12, s.nextFloat());
        assertEquals((float)-4.567E14, s.nextFloat());
        assertEquals((float)1.23456789E-5, s.nextFloat());

        s = new Scanner("NaN Infinity -Infinity");
        assertEquals(Float.NaN, s.nextFloat());
        assertEquals(Float.POSITIVE_INFINITY, s.nextFloat());
        assertEquals(Float.NEGATIVE_INFINITY, s.nextFloat());

        String str=String.valueOf(Float.MAX_VALUE*2);
        s=new Scanner(str);
        assertEquals(Float.POSITIVE_INFINITY,s.nextFloat());

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals((float)23456.0, s.nextFloat());
        s.useLocale(Locale.GERMANY);
        assertEquals((float)23.456, s.nextFloat());

        s = new Scanner("23.456 23.456");
        s.useLocale(Locale.ENGLISH);
        assertEquals((float)23.456, s.nextFloat());
        s.useLocale(Locale.GERMANY);
        assertEquals((float)23456.0, s.nextFloat());

        s = new Scanner("23,456.7 23.456,7");
        s.useLocale(Locale.ENGLISH);
        assertEquals((float)23456.7, s.nextFloat());
        s.useLocale(Locale.GERMANY);
        assertEquals((float)23456.7, s.nextFloat());

        s = new Scanner("-123.4 123.4- -123.4-");
        s.useLocale(new Locale("ar", "AE"));
        // FIXME
//        assertEquals((float)-123.4, s.nextFloat());
//        //The following test case fails on RI
//        assertEquals((float)-123.4, s.nextFloat());
        try {
            s.nextFloat();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("123- -123");
        s.useLocale(new Locale("mk", "MK"));
        try {
            s.nextFloat();
            fail();
        } catch (InputMismatchException expected) {
        }
        // Skip the un-recognizable token 123-.
        assertEquals("123-", s.next());
        assertEquals((float)-123.0, s.nextFloat());

    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextBigInteger(int)
     */
    public void test_nextBigIntegerI() throws IOException {
        s = new Scanner("123 456");
        assertEquals(new BigInteger("123"), s.nextBigInteger(10));
        assertEquals(new BigInteger("456"), s.nextBigInteger(10));
        try {
            s.nextBigInteger(10);
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        assertEquals(new BigInteger("38"), s.nextBigInteger(5));
        try {
            s.nextBigInteger(5);
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextBigInteger(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertEquals(new BigInteger("23456"), s.nextBigInteger(10));
        assertEquals(new BigInteger("23456"), s.nextBigInteger(10));

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextBigInteger(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertEquals(new BigInteger("23456"), s.nextBigInteger(10));
        assertEquals(new BigInteger("23456"), s.nextBigInteger(10));

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertEquals(new BigInteger("102"), s.nextBigInteger(10));
        try {
            s.nextBigInteger(5);
            fail();
        } catch (InputMismatchException expected) {
        }
        assertEquals(new BigInteger("162"), s.nextBigInteger(10));

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        try {
            s.nextBigInteger(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertEquals(new BigInteger("23456"), s.nextBigInteger(10));
        assertEquals(new BigInteger("23456"), s.nextBigInteger(10));

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        try {
            s.nextBigInteger(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertEquals(new BigInteger("3456"), s.nextBigInteger(10));

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(new BigInteger("3456"), s.nextBigInteger(10));

        s = new Scanner("E34");
        assertEquals(new BigInteger("3636"), s.nextBigInteger(16));

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertEquals(new BigInteger("12300"), s.nextBigInteger(10));

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertEquals(new BigInteger("12300"), s.nextBigInteger(10));

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertEquals(new BigInteger("12300"), s.nextBigInteger(10));

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(new BigInteger("-123"), s.nextBigInteger(10));


        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertEquals(new BigInteger("-123"), s.nextBigInteger(10));
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextBigInteger()
     */
    public void test_nextBigInteger() throws IOException {
        s = new Scanner("123 456");
        assertEquals(new BigInteger("123"), s.nextBigInteger());
        assertEquals(new BigInteger("456"), s.nextBigInteger());
        try {
            s.nextBigInteger();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        s.useRadix(5);
        assertEquals(new BigInteger("38"), s.nextBigInteger());
        try {
            s.nextBigInteger();
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextBigInteger();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertEquals(new BigInteger("23456"), s.nextBigInteger());
        assertEquals(new BigInteger("23456"), s.nextBigInteger());

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextBigInteger();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertEquals(new BigInteger("23456"), s.nextBigInteger());
        assertEquals(new BigInteger("23456"), s.nextBigInteger());

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertEquals(new BigInteger("102"), s.nextBigInteger());
        s.useRadix(5);
        try {
            s.nextBigInteger();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useRadix(10);
        assertEquals(new BigInteger("162"), s.nextBigInteger());

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        try {
            s.nextBigInteger();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertEquals(new BigInteger("23456"), s.nextBigInteger());
        assertEquals(new BigInteger("23456"), s.nextBigInteger());

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        try {
            s.nextBigInteger();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertEquals(new BigInteger("3456"), s.nextBigInteger());

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(new BigInteger("3456"), s.nextBigInteger());

        s = new Scanner("E34");
        s.useRadix(16);
        assertEquals(new BigInteger("3636"), s.nextBigInteger());

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertEquals(new BigInteger("12300"), s.nextBigInteger());

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertEquals(new BigInteger("12300"), s.nextBigInteger());

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertEquals(new BigInteger("12300"), s.nextBigInteger());

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(new BigInteger("-123"), s.nextBigInteger());

        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertEquals(new BigInteger("-123"), s.nextBigInteger());
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextShort(int)
     */
    public void test_nextShortI() throws IOException {
        s = new Scanner("123 456");
        assertEquals(123, s.nextShort(10));
        assertEquals(456, s.nextShort(10));
        try {
            s.nextShort(10);
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        assertEquals(38, s.nextShort(5));
        try {
            s.nextShort(5);
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("123456789");
        try {
            s.nextShort(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextShort(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextShort(10));
        assertEquals(23456, s.nextShort(10));

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextShort(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextShort(10));
        assertEquals(23456, s.nextShort(10));

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertEquals(102, s.nextShort(10));
        try {
            s.nextShort(5);
            fail();
        } catch (InputMismatchException expected) {
        }
        assertEquals(162, s.nextShort(10));

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        try {
            s.nextShort(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextShort(10));
        assertEquals(23456, s.nextShort(10));

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        try {
            s.nextShort(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertEquals(3456, s.nextShort(10));

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(3456, s.nextShort(10));

        s = new Scanner("E34");
        assertEquals(3636, s.nextShort(16));

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextShort(10));

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextShort(10));

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextShort(10));

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(-123, s.nextShort(10));


        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertEquals(-123, s.nextShort(10));
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextShort()
     */
    public void test_nextShort() throws IOException {
        s = new Scanner("123 456");
        assertEquals(123, s.nextShort());
        assertEquals(456, s.nextShort());
        try {
            s.nextShort();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        s.useRadix(5);
        assertEquals(38, s.nextShort());
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("123456789");
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextShort());
        assertEquals(23456, s.nextShort());

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextShort());
        assertEquals(23456, s.nextShort());

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertEquals(102, s.nextShort());
        s.useRadix(5);
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useRadix(10);
        assertEquals(162, s.nextShort());

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextShort());
        assertEquals(23456, s.nextShort());

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertEquals(3456, s.nextShort());

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(3456, s.nextShort());

        s = new Scanner("E34");
        s.useRadix(16);
        assertEquals(3636, s.nextShort());

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextShort());

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextShort());

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextShort());

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(-123, s.nextShort());

        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertEquals(-123, s.nextShort());
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextLong(int)
     */
    public void test_nextLongI() throws IOException {
        s = new Scanner("123 456");
        assertEquals(123, s.nextLong(10));
        assertEquals(456, s.nextLong(10));
        try {
            s.nextLong(10);
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        assertEquals(38, s.nextLong(5));
        try {
            s.nextLong(5);
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("123456789123456789123456789123456789");
        try {
            s.nextLong(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextLong(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextLong(10));
        assertEquals(23456, s.nextLong(10));

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextLong(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextLong(10));
        assertEquals(23456, s.nextLong(10));

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertEquals(102, s.nextLong(10));
        try {
            s.nextLong(5);
            fail();
        } catch (InputMismatchException expected) {
        }
        assertEquals(162, s.nextLong(10));

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        try {
            s.nextLong(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextLong(10));
        assertEquals(23456, s.nextLong(10));

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        try {
            s.nextLong(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertEquals(3456, s.nextLong(10));

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(3456, s.nextLong(10));

        s = new Scanner("E34");
        assertEquals(3636, s.nextLong(16));

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextLong(10));

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextLong(10));

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextLong(10));

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(-123, s.nextLong(10));


        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertEquals(-123, s.nextLong(10));
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextLong()
     */
    public void test_nextLong() throws IOException {
        s = new Scanner("123 456");
        assertEquals(123, s.nextLong());
        assertEquals(456, s.nextLong());
        try {
            s.nextLong();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        s.useRadix(5);
        assertEquals(38, s.nextLong());
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("123456789123456789123456789123456789");
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextLong());
        assertEquals(23456, s.nextLong());

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextLong());
        assertEquals(23456, s.nextLong());

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertEquals(102, s.nextLong());
        s.useRadix(5);
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useRadix(10);
        assertEquals(162, s.nextLong());

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertEquals(23456, s.nextLong());
        assertEquals(23456, s.nextLong());

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertEquals(3456, s.nextLong());

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(3456, s.nextLong());

        s = new Scanner("E34");
        s.useRadix(16);
        assertEquals(3636, s.nextLong());

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextLong());

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextLong());

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertEquals(12300, s.nextLong());

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(-123, s.nextLong());

        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertEquals(-123, s.nextLong());
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNext()
     */
    public void test_hasNext() throws IOException {
        s = new Scanner("1##2").useDelimiter("\\#");
        assertTrue(s.hasNext());
        assertEquals("1", s.next());
        assertEquals("", s.next());
        assertEquals("2", s.next());
        assertFalse(s.hasNext());
        s.close();
        try {
            s.hasNext();
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("1( )2( )").useDelimiter("\\( \\)");
        assertTrue(s.hasNext());
        assertTrue(s.hasNext());
        assertEquals("1", s.next());
        assertEquals("2", s.next());

        s = new Scanner("1 2  ").useDelimiter("( )");
        assertEquals("1", s.next());
        assertEquals("2", s.next());
        assertTrue(s.hasNext());
        assertEquals("", s.next());

        s = new Scanner("1\n2  ");
        assertEquals("1", s.next());
        assertTrue(s.hasNext());
        assertEquals("2", s.next());
        assertFalse(s.hasNext());
        // test boundary case
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("1'\n'2  ");
        assertEquals("1'", s.next());
        assertTrue(s.hasNext());
        assertEquals("'2", s.next());
        assertFalse(s.hasNext());
        // test boundary case
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("  ");
        assertFalse(s.hasNext());

        // test socket inputStream

        os.write("1 2".getBytes());
        serverSocket.close();

        s = new Scanner(client);
        assertEquals("1", s.next());
        assertTrue(s.hasNext());
        assertEquals("2", s.next());
        assertFalse(s.hasNext());
        try {
            s.next();
            fail();
        } catch (NoSuchElementException expected) {
        }
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNext(Pattern)
     */
    public void test_hasNextLPattern() throws IOException {
        Pattern pattern;
        s = new Scanner("aab@2@abb@").useDelimiter("\\@");
        pattern = Pattern.compile("a*b");
        assertTrue(s.hasNext(pattern));
        assertEquals("aab", s.next(pattern));
        assertFalse(s.hasNext(pattern));
        try {
            s.next(pattern);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("word ? ");
        pattern = Pattern.compile("\\w+");
        assertTrue(s.hasNext(pattern));
        assertEquals("word", s.next(pattern));
        assertFalse(s.hasNext(pattern));
        try {
            s.next(pattern);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("word1 WorD2  ");
        pattern = Pattern.compile("\\w+");
        assertTrue(s.hasNext(pattern));
        assertEquals("word1", s.next(pattern));
        assertTrue(s.hasNext(pattern));
        assertEquals("WorD2", s.next(pattern));
        assertFalse(s.hasNext(pattern));
        try {
            s.next(pattern);
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("word1 WorD2  ");
        pattern = Pattern.compile("\\w+");
        try {
            s.hasNext((Pattern) null);
            fail();
        } catch (NullPointerException expected) {
        }
        s.close();
        try {
            s.hasNext(pattern);
            fail();
        } catch (IllegalStateException expected) {
        }

        // test socket inputStream
        os.write("aab b".getBytes());
        serverSocket.close();

        s = new Scanner(client);
        pattern = Pattern.compile("a+b");
        assertTrue(s.hasNext(pattern));
        assertEquals("aab", s.next(pattern));
        assertFalse(s.hasNext(pattern));
        try {
            s.next(pattern);
            fail();
        } catch (InputMismatchException expected) {
        }
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNext(String)
     */
    public void test_hasNextLString() throws IOException {
        s = new Scanner("aab@2@abb@").useDelimiter("\\@");
        try {
            s.hasNext((String)null);
            fail();
        } catch (NullPointerException expected) {
        }

        s = new Scanner("aab*b*").useDelimiter("\\*");
        assertTrue(s.hasNext("a+b"));
        assertEquals("aab", s.next("a+b"));
        assertFalse(s.hasNext("a+b"));
        try {
            s.next("a+b");
            fail();
        } catch (InputMismatchException expected) {
        }
        s.close();
        try {
            s.hasNext("a+b");
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("WORD ? ");
        assertTrue(s.hasNext("\\w+"));
        assertEquals("WORD", s.next("\\w+"));
        assertFalse(s.hasNext("\\w+"));
        try {
            s.next("\\w+");
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("word1 word2  ");
        assertEquals("word1", s.next("\\w+"));
        assertEquals("word2", s.next("\\w+"));
        // test boundary case
        try {
            s.next("\\w+");
            fail();
        } catch (NoSuchElementException expected) {
        }

        // test socket inputStream

        os.write("aab 2".getBytes());
        serverSocket.close();

        s = new Scanner(client);
        assertTrue(s.hasNext("a*b"));
        assertEquals("aab", s.next("a*b"));
        assertFalse(s.hasNext("a*b"));
        try {
            s.next("a*b");
            fail();
        } catch (InputMismatchException expected) {
        }
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextBoolean()
     */
    public void test_hasNextBoolean() throws IOException {

        s = new Scanner("TRue");
        assertTrue(s.hasNextBoolean());
        assertTrue(s.nextBoolean());

        s = new Scanner("tRue false");
        assertTrue(s.hasNextBoolean());
        assertTrue(s.nextBoolean());
        assertTrue(s.hasNextBoolean());
        assertFalse(s.nextBoolean());

        s = new Scanner("");
        assertFalse(s.hasNextBoolean());

        // test socket inputStream

        os.write("true false ".getBytes());
        serverSocket.close();

        s = new Scanner(client);
        assertTrue(s.hasNextBoolean());
        assertTrue(s.nextBoolean());

        // ues '*' as delimiter
        s = new Scanner("true**false").useDelimiter("\\*");
        assertTrue(s.hasNextBoolean());
        assertTrue(s.nextBoolean());
        assertFalse(s.hasNextBoolean());
        try {
            s.nextBoolean();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("false( )").useDelimiter("\\( \\)");
        assertTrue(s.hasNextBoolean());
        assertFalse(s.nextBoolean());
        assertFalse(s.hasNextBoolean());

    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextByte(int)
     */
    public void test_hasNextByteI() throws IOException {
        s = new Scanner("123 126");
        assertTrue(s.hasNextByte(10));
        assertEquals(123, s.nextByte(10));
        assertTrue(s.hasNextByte(10));
        assertEquals(126, s.nextByte(10));
        assertFalse(s.hasNextByte(10));
        try {
            s.nextByte(10);
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 126");
        assertTrue(s.hasNextByte(5));
        assertEquals(38, s.nextByte(5));
        assertFalse(s.hasNextByte(5));
        try {
            s.nextByte(5);
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("1234");
        assertFalse(s.hasNextByte(10));
        try {
            s.nextByte(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 12\u0666");
        assertTrue(s.hasNextByte(10));
        assertEquals(102, s.nextByte(10));
        assertFalse(s.hasNextByte(5));
        try {
            s.nextByte(5);
            fail();
        } catch (InputMismatchException expected) {
        }
        assertTrue(s.hasNextByte(10));
        assertEquals(126, s.nextByte(10));

        s = new Scanner("012");
        assertTrue(s.hasNextByte(10));
        assertEquals(12, s.nextByte(10));

        s = new Scanner("E");
        assertTrue(s.hasNextByte(16));
        assertEquals(14, s.nextByte(16));

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("100");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextByte(10));
        assertEquals(100, s.nextByte(10));

        s = new Scanner("1\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextByte(10));
        assertEquals(100, s.nextByte(10));

        s = new Scanner("1\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextByte(10));
        assertEquals(100, s.nextByte(10));

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertTrue(s.hasNextByte(10));
        assertEquals(-123, s.nextByte(10));


        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertTrue(s.hasNextByte(10));
        assertEquals(-123, s.nextByte(10));
    }

    // This is a bogus test : The cached value is returned only if the radix
    // matches.
    public void test_hasNextByteI_cache() throws IOException{
        //regression for HARMONY-2063
        s = new Scanner("123 45");
        assertTrue(s.hasNextByte(8));
        // Note that the cached value isn't returned here.
        assertEquals(123, s.nextByte());
        assertEquals(45, s.nextByte());

        s = new Scanner("123 45");
        assertTrue(s.hasNextByte(10));
        assertTrue(s.hasNextByte(8));

        // The values are returned according to the supplied radix.
        assertEquals(123, s.nextByte());
        assertEquals(45, s.nextByte());

        s = new Scanner("-123 -45");
        assertTrue(s.hasNextByte(8));
        assertEquals(-123, s.nextInt());
        assertEquals(-45, s.nextByte());

        s = new Scanner("123 45");
        assertTrue(s.hasNextByte());
        s.close();
        try {
          s.nextByte();
          fail();
        } catch (IllegalStateException expected) {
        }
    }

    public void test_hasNextByte() throws IOException {
        s = new Scanner("123 126");
        assertTrue(s.hasNextByte());
        assertEquals(123, s.nextByte());
        assertTrue(s.hasNextByte());
        assertEquals(126, s.nextByte());
        assertFalse(s.hasNextByte());
        try {
            s.nextByte();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 126");
        s.useRadix(5);
        assertTrue(s.hasNextByte());
        assertEquals(38, s.nextByte());
        assertFalse(s.hasNextByte());
        try {
            s.nextByte();
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("1234");
        assertFalse(s.hasNextByte());
        try {
            s.nextByte();
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 12\u0666");
        assertTrue(s.hasNextByte());
        assertEquals(102, s.nextByte());
        s.useRadix(5);
        assertFalse(s.hasNextByte());
        try {
            s.nextByte();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useRadix(10);
        assertTrue(s.hasNextByte());
        assertEquals(126, s.nextByte());

        s = new Scanner("012");
        assertEquals(12, s.nextByte());

        s = new Scanner("E");
        s.useRadix(16);
        assertTrue(s.hasNextByte());
        assertEquals(14, s.nextByte());

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("100");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextByte());
        assertEquals(100, s.nextByte());

        s = new Scanner("1\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextByte());
        assertEquals(100, s.nextByte());

        s = new Scanner("1\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextByte());
        assertEquals(100, s.nextByte());

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertTrue(s.hasNextByte());
        assertEquals(-123, s.nextByte());

        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertTrue(s.hasNextByte());
        assertEquals(-123, s.nextByte());
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextBigInteger(int)
     */
    public void test_hasNextBigIntegerI() throws IOException {
        s = new Scanner("123 456");
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("123"), s.nextBigInteger(10));
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("456"), s.nextBigInteger(10));
        assertFalse(s.hasNextBigInteger(10));
        try {
            s.nextBigInteger(10);
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        assertTrue(s.hasNextBigInteger(5));
        assertEquals(new BigInteger("38"), s.nextBigInteger(5));
        assertFalse(s.hasNextBigInteger(5));
        try {
            s.nextBigInteger(5);
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextBigInteger(10));
        try {
            s.nextBigInteger(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("23456"), s.nextBigInteger(10));
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("23456"), s.nextBigInteger(10));

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextBigInteger(10));
        try {
            s.nextBigInteger(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("23456"), s.nextBigInteger(10));
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("23456"), s.nextBigInteger(10));

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("102"), s.nextBigInteger(10));
        assertFalse(s.hasNextBigInteger(5));
        try {
            s.nextBigInteger(5);
            fail();
        } catch (InputMismatchException expected) {
        }
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("162"), s.nextBigInteger(10));

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        assertFalse(s.hasNextBigInteger(10));
        try {
            s.nextBigInteger(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("23456"), s.nextBigInteger(10));
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("23456"), s.nextBigInteger(10));

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        assertFalse(s.hasNextBigInteger(10));
        try {
            s.nextBigInteger(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("3456"), s.nextBigInteger(10));

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("3456"), s.nextBigInteger(10));

        s = new Scanner("E34");
        assertTrue(s.hasNextBigInteger(16));
        assertEquals(new BigInteger("3636"), s.nextBigInteger(16));

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("12300"), s.nextBigInteger(10));

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("12300"), s.nextBigInteger(10));

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("12300"), s.nextBigInteger(10));

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("-123"), s.nextBigInteger(10));


        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("-123"), s.nextBigInteger(10));
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextBigInteger(int)
     */
    public void test_hasNextBigIntegerI_cache() throws IOException {
        //regression for HARMONY-2063
        s = new Scanner("123 123456789123456789");
        assertTrue(s.hasNextBigInteger(16));
        assertEquals(new BigInteger("123"), s.nextBigInteger());
        assertEquals(new BigInteger("123456789123456789"), s.nextBigInteger());

        s = new Scanner("123456789123456789 456");
        assertTrue(s.hasNextBigInteger(16));
        assertTrue(s.hasNextBigInteger(10));
        assertEquals(new BigInteger("123456789123456789"), s.nextBigInteger());
        assertEquals(new BigInteger("456"), s.nextBigInteger());

        s = new Scanner("-123 -123456789123456789");
        assertTrue(s.hasNextBigInteger(8));
        assertEquals(-123, s.nextShort());
        assertEquals(new BigInteger("-123456789123456789"), s.nextBigInteger());

        s = new Scanner("123 456");
        assertTrue(s.hasNextBigInteger());
        s.close();
        try {
            s.nextBigInteger();
            fail();
        } catch (IllegalStateException expected) {
        }
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextBigInteger()
     */
    public void test_hasNextBigInteger() throws IOException {
        s = new Scanner("123 456");
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("123"), s.nextBigInteger());
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("456"), s.nextBigInteger());
        assertFalse(s.hasNextBigInteger());
        try {
            s.nextBigInteger();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        s.useRadix(5);
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("38"), s.nextBigInteger());
        assertFalse(s.hasNextBigInteger());
        try {
            s.nextBigInteger();
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextBigInteger());
        try {
            s.nextBigInteger();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("23456"), s.nextBigInteger());
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("23456"), s.nextBigInteger());

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextBigInteger());
        try {
            s.nextBigInteger();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("23456"), s.nextBigInteger());
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("23456"), s.nextBigInteger());

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertEquals(new BigInteger("102"), s.nextBigInteger());
        s.useRadix(5);
        assertFalse(s.hasNextBigInteger());
        try {
            s.nextBigInteger();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useRadix(10);
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("162"), s.nextBigInteger());

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        assertFalse(s.hasNextBigInteger());
        try {
            s.nextBigInteger();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("23456"), s.nextBigInteger());
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("23456"), s.nextBigInteger());

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        assertFalse(s.hasNextBigInteger());
        try {
            s.nextBigInteger();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("3456"), s.nextBigInteger());

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("3456"), s.nextBigInteger());

        s = new Scanner("E34");
        s.useRadix(16);
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("3636"), s.nextBigInteger());

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("12300"), s.nextBigInteger());

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("12300"), s.nextBigInteger());

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("12300"), s.nextBigInteger());

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("-123"), s.nextBigInteger());

        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertTrue(s.hasNextBigInteger());
        assertEquals(new BigInteger("-123"), s.nextBigInteger());
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextInt(int)
     */
    public void test_hasNextIntI() throws IOException {
        s = new Scanner("123 456");
        assertEquals(123, s.nextInt(10));
        assertTrue(s.hasNextInt(10));
        assertEquals(456, s.nextInt(10));
        assertFalse(s.hasNextInt(10));
        try {
            s.nextInt(10);
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        assertTrue(s.hasNextInt(5));
        assertEquals(38, s.nextInt(5));
        assertFalse(s.hasNextInt(5));
        try {
            s.nextInt(5);
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("123456789123456789123456789123456789");
        assertFalse(s.hasNextInt(10));

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextInt(10));
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextInt(10));
        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextInt(10));
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextInt(10));

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06662");
        assertTrue(s.hasNextInt(10));
        assertFalse(s.hasNextInt(5));

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666");
        s.useLocale(Locale.CHINESE);
        assertFalse(s.hasNextInt(10));
        try {
            s.nextInt(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        assertTrue(s.hasNextInt(10));

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        assertFalse(s.hasNextInt(10));
        try {
            s.nextInt(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertTrue(s.hasNextInt(10));
        assertEquals(3456, s.nextInt(10));

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextInt(10));
        assertEquals(3456, s.nextInt(10));

        s = new Scanner("E3456");
        assertTrue(s.hasNextInt(16));
        assertEquals(930902, s.nextInt(16));
        // The following test case fails on RI, because RI does not support
        // letter as leading digit
        s = new Scanner("E3,456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextInt(16));
        assertEquals(930902, s.nextInt(16));

        // If parameter radix is illegal, the following test case fails on RI
        try {
            s.hasNextInt(Character.MIN_RADIX - 1);
            fail();
        } catch (IllegalArgumentException expected) {
        }

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextInt(10));
        assertEquals(12300, s.nextInt(10));

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextInt(10));
        assertEquals(12300, s.nextInt(10));

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextInt(10));
        assertEquals(12300, s.nextInt(10));

        s = new Scanner("-123 123-");
        s.useLocale(new Locale("ar", "AE"));
        assertTrue(s.hasNextInt(10));
        assertEquals(-123, s.nextInt(10));
        assertFalse(s.hasNextInt(10));
        try {
            s.nextInt(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("-123 -123-");
        s.useLocale(new Locale("ar", "AE"));
        assertEquals(-123, s.nextInt(10));
        assertFalse(s.hasNextInt(10));
        try {
            s.nextInt(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("-123 123-");
        s.useLocale(new Locale("mk", "MK"));
        assertTrue(s.hasNextInt(10));
        assertEquals(-123, s.nextInt(10));
        assertFalse(s.hasNextInt(10));
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }
        // Skip the un-recognizable token 123-.
        assertEquals("123-", s.next());
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextInt(int)
     */
    public void test_hasNextIntI_cache() throws IOException {
        //regression for HARMONY-2063
        s = new Scanner("123 456");
        assertTrue(s.hasNextInt(16));
        assertEquals(123, s.nextInt(10));
        assertEquals(456, s.nextInt());

        s = new Scanner("123 456");
        assertTrue(s.hasNextInt(16));
        assertTrue(s.hasNextInt(8));
        assertEquals(123, s.nextInt());
        assertEquals(456, s.nextInt());

        s = new Scanner("-123 -456 -789");
        assertTrue(s.hasNextInt(8));
        assertEquals(-123, s.nextShort());
        assertEquals(-456, s.nextInt());
        assertTrue(s.hasNextShort(16));
        assertEquals(-789, s.nextInt());

        s = new Scanner("123 456");
        assertTrue(s.hasNextInt());
        s.close();
        try {
            s.nextInt();
            fail();
        } catch (IllegalStateException expected) {
        }
    }
    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextInt()
     */
    public void test_hasNextInt() throws IOException {
        s = new Scanner("123 456");
        assertTrue(s.hasNextInt());
        assertEquals(123, s.nextInt());
        assertEquals(456, s.nextInt());
        assertFalse(s.hasNextInt());
        try {
            s.nextInt();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        s.useRadix(5);
        assertTrue(s.hasNextInt());
        assertEquals(38, s.nextInt());
        assertFalse(s.hasNextInt());
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("123456789123456789123456789123456789");
        assertFalse(s.hasNextInt());

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextInt());
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextInt());

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextInt());
        s.useLocale(new Locale("it", "CH"));
        assertTrue(s.hasNextInt());

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06662");
        s.useRadix(5);
        assertFalse(s.hasNextInt());

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666");
        s.useLocale(Locale.CHINESE);
        assertFalse(s.hasNextInt());
        s.useLocale(Locale.GERMANY);
        assertTrue(s.hasNextInt());

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        assertFalse(s.hasNextInt());
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertTrue(s.hasNextInt());
        assertEquals(3456, s.nextInt());

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(3456, s.nextInt());

        s = new Scanner("E3456");
        s.useRadix(16);
        assertTrue(s.hasNextInt());
        assertEquals(930902, s.nextInt());

        // The following test case fails on RI, because RI does not support
        // letter as leading digit
        s = new Scanner("E3,456");
        s.useLocale(Locale.ENGLISH);
        s.useRadix(16);
        assertTrue(s.hasNextInt());
        assertEquals(930902, s.nextInt());

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextInt());
        assertEquals(12300, s.nextInt());

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextInt());
        assertEquals(12300, s.nextInt());

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextInt());
        assertEquals(12300, s.nextInt());

        s = new Scanner("-123 123-");
        s.useLocale(new Locale("ar", "AE"));
        assertTrue(s.hasNextInt());
        assertEquals(-123, s.nextInt());
        assertFalse(s.hasNextInt());
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("-123 -123-");
        s.useLocale(new Locale("ar", "AE"));
        assertTrue(s.hasNextInt());
        assertEquals(-123, s.nextInt());
        assertFalse(s.hasNextInt());
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("-123 123-");
        s.useLocale(new Locale("mk", "MK"));
        assertTrue(s.hasNextInt());
        assertEquals(-123, s.nextInt());
        try {
            s.nextInt();
            fail();
        } catch (InputMismatchException expected) {
        }
        // Skip the un-recognizable token 123-.
        assertEquals("123-", s.next());
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextFloat()
     */
    public void test_hasNextFloat() throws IOException {
        s = new Scanner("123 45\u0666. 123.4 .123 ");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextFloat());
        assertEquals((float)123.0, s.nextFloat());
        assertTrue(s.hasNextFloat());
        assertEquals((float)456.0, s.nextFloat());
        assertTrue(s.hasNextFloat());
        assertEquals((float)123.4, s.nextFloat());
        assertTrue(s.hasNextFloat());
        assertEquals((float)0.123, s.nextFloat());
        assertFalse(s.hasNextFloat());
        try {
            s.nextFloat();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("+123.4 -456.7 123,456.789 0.1\u06623,4");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextFloat());
        assertEquals((float)123.4, s.nextFloat());
        assertTrue(s.hasNextFloat());
        assertEquals((float)-456.7, s.nextFloat());
        assertTrue(s.hasNextFloat());
        assertEquals((float)123456.789, s.nextFloat());
        assertFalse(s.hasNextFloat());
        try {
            s.nextFloat();
            fail();
        } catch (InputMismatchException expected) {
        }

        // Scientific notation
        s = new Scanner("+123.4E10 -456.7e+12 123,456.789E-10");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextFloat());
        assertEquals((float)1.234E12, s.nextFloat());
        assertTrue(s.hasNextFloat());
        assertEquals((float)-4.567E14, s.nextFloat());
        assertTrue(s.hasNextFloat());
        assertEquals((float)1.23456789E-5, s.nextFloat());

        s = new Scanner("NaN Infinity -Infinity");
        assertTrue(s.hasNextFloat());
        assertEquals(Float.NaN, s.nextFloat());
        assertTrue(s.hasNextFloat());
        assertEquals(Float.POSITIVE_INFINITY, s.nextFloat());
        assertTrue(s.hasNextFloat());
        assertEquals(Float.NEGATIVE_INFINITY, s.nextFloat());

        String str=String.valueOf(Float.MAX_VALUE*2);
        s=new Scanner(str);
        assertTrue(s.hasNextFloat());
        assertEquals(Float.POSITIVE_INFINITY,s.nextFloat());

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextFloat());
        assertEquals((float)23456.0, s.nextFloat());
        s.useLocale(Locale.GERMANY);
        assertTrue(s.hasNextFloat());
        assertEquals((float)23.456, s.nextFloat());

        s = new Scanner("23.456 23.456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextFloat());
        assertEquals((float)23.456, s.nextFloat());
        s.useLocale(Locale.GERMANY);
        assertTrue(s.hasNextFloat());
        assertEquals((float)23456.0, s.nextFloat());

        s = new Scanner("23,456.7 23.456,7");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextFloat());
        assertEquals((float)23456.7, s.nextFloat());
        s.useLocale(Locale.GERMANY);
        assertTrue(s.hasNextFloat());
        assertEquals((float)23456.7, s.nextFloat());

        //FIXME
//        s = new Scanner("-123.4 123.4- -123.4-");
//        s.useLocale(new Locale("ar", "AE"));
//        assertTrue(s.hasNextFloat());
//        assertEquals((float)-123.4, s.nextFloat());
//        //The following test case fails on RI
//        assertTrue(s.hasNextFloat());
//        assertEquals((float)-123.4, s.nextFloat());
//        try {
//            s.nextFloat();
//            fail();
//        } catch (InputMismatchException expected) {
//        }

        s = new Scanner("123- -123");
        s.useLocale(new Locale("mk", "MK"));
        assertFalse(s.hasNextFloat());
        try {
            s.nextFloat();
            fail();
        } catch (InputMismatchException expected) {
        }
        // Skip the un-recognizable token 123-.
        assertEquals("123-", s.next());
        assertTrue(s.hasNextFloat());
        assertEquals((float)-123.0, s.nextFloat());

        s = new Scanner("+123.4 -456.7");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextFloat());
        s.close();
        try{
            s.nextFloat();
            fail();
        }catch(IllegalStateException expected) {
        }

    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextShort(int)
     */
    public void test_hasNextShortI() throws IOException {
        s = new Scanner("123 456");
        assertTrue(s.hasNextShort(10));
        assertEquals(123, s.nextShort(10));
        assertTrue(s.hasNextShort(10));
        assertEquals(456, s.nextShort(10));
        assertFalse(s.hasNextShort(10));
        try {
            s.nextShort(10);
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        assertTrue(s.hasNextShort(5));
        assertEquals(38, s.nextShort(5));
        assertFalse(s.hasNextShort(5));
        try {
            s.nextShort(5);
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("123456789");
        assertFalse(s.hasNextShort(10));
        try {
            s.nextShort(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextShort(10));
        try {
            s.nextShort(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextShort(10));
        assertEquals(23456, s.nextInt(10));
        assertTrue(s.hasNextShort(10));
        assertEquals(23456, s.nextInt(10));

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextShort(10));
        try {
            s.nextShort(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextShort(10));
        assertEquals(23456, s.nextShort(10));
        assertTrue(s.hasNextShort(10));
        assertEquals(23456, s.nextShort(10));

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertTrue(s.hasNextShort(10));
        assertEquals(102, s.nextShort(10));
        assertFalse(s.hasNextShort(5));
        try {
            s.nextShort(5);
            fail();
        } catch (InputMismatchException expected) {
        }
        assertTrue(s.hasNextShort(10));
        assertEquals(162, s.nextShort(10));

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        assertFalse(s.hasNextShort(10));
        try {
            s.nextShort(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextShort(10));
        assertEquals(23456, s.nextShort(10));
        assertTrue(s.hasNextShort(10));
        assertEquals(23456, s.nextShort(10));

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        assertFalse(s.hasNextShort(10));
        try {
            s.nextShort(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertTrue(s.hasNextShort(10));
        assertEquals(3456, s.nextShort(10));

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextShort(10));
        assertEquals(3456, s.nextShort(10));

        s = new Scanner("E34");
        assertTrue(s.hasNextShort(16));
        assertEquals(3636, s.nextShort(16));

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextShort(10));
        assertEquals(12300, s.nextShort(10));

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextShort(10));
        assertEquals(12300, s.nextShort(10));

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextShort(10));
        assertEquals(12300, s.nextShort(10));

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertTrue(s.hasNextShort(10));
        assertEquals(-123, s.nextShort(10));


        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertTrue(s.hasNextShort(10));
        assertEquals(-123, s.nextShort(10));
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextShort()
     */
    public void test_hasNextShort() throws IOException {
        s = new Scanner("123 456");
        assertTrue(s.hasNextShort());
        assertEquals(123, s.nextShort());
        assertTrue(s.hasNextShort());
        assertEquals(456, s.nextShort());
        assertFalse(s.hasNextShort());
        try {
            s.nextShort();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        s.useRadix(5);
        assertTrue(s.hasNextShort());
        assertEquals(38, s.nextShort());
        assertFalse(s.hasNextShort());
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("123456789");
        assertFalse(s.hasNextShort());
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextShort());
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextShort());
        assertEquals(23456, s.nextShort());
        assertTrue(s.hasNextShort());
        assertEquals(23456, s.nextShort());

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextShort());
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextShort());
        assertEquals(23456, s.nextShort());
        assertTrue(s.hasNextShort());
        assertEquals(23456, s.nextShort());

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertEquals(102, s.nextShort());
        s.useRadix(5);
        assertFalse(s.hasNextShort());
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useRadix(10);
        assertTrue(s.hasNextShort());
        assertEquals(162, s.nextShort());

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        assertFalse(s.hasNextShort());
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextShort());
        assertEquals(23456, s.nextShort());
        assertTrue(s.hasNextShort());
        assertEquals(23456, s.nextShort());

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        assertFalse(s.hasNextShort());
        try {
            s.nextShort();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertTrue(s.hasNextShort());
        assertEquals(3456, s.nextShort());

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextShort());
        assertEquals(3456, s.nextShort());

        s = new Scanner("E34");
        s.useRadix(16);
        assertTrue(s.hasNextShort());
        assertEquals(3636, s.nextShort());

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextShort());
        assertEquals(12300, s.nextShort());

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextShort());
        assertEquals(12300, s.nextShort());

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextShort());
        assertEquals(12300, s.nextShort());

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertTrue(s.hasNextShort());
        assertEquals(-123, s.nextShort());

        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertTrue(s.hasNextShort());
        assertEquals(-123, s.nextShort());
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextShort(int)
     */
    public void test_hasNextShortI_cache() throws IOException {
        //regression for HARMONY-2063
        s = new Scanner("123 456");
        assertTrue(s.hasNextShort(16));
        assertEquals(123, s.nextShort());
        assertEquals(456, s.nextShort());

        s = new Scanner("123 456");
        assertTrue(s.hasNextShort(16));
        assertTrue(s.hasNextShort(8));
        assertEquals(123, s.nextShort());
        assertEquals(456, s.nextShort());

        s = new Scanner("-123 -456 -789");
        assertTrue(s.hasNextShort(8));
        assertEquals(-123, s.nextInt());
        assertEquals(-456, s.nextShort());
        assertTrue(s.hasNextInt(16));
        assertEquals(-789, s.nextShort());

        s = new Scanner("123 456");
        assertTrue(s.hasNextShort());
        s.close();
        try {
            s.nextShort();
            fail();
        } catch (IllegalStateException expected) {
        }
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextLong(int)
     */
    public void test_hasNextLongI() throws IOException {
        s = new Scanner("123 456");
        assertTrue(s.hasNextLong(10));
        assertEquals(123, s.nextLong(10));
        assertTrue(s.hasNextLong(10));
        assertEquals(456, s.nextLong(10));
        assertFalse(s.hasNextLong(10));
        try {
            s.nextLong(10);
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        assertTrue(s.hasNextLong(5));
        assertEquals(38, s.nextLong(5));
        assertFalse(s.hasNextLong(5));
        try {
            s.nextLong(5);
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("123456789123456789123456789123456789");
        assertFalse(s.hasNextLong(10));
        try {
            s.nextLong(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextShort(10));
        try {
            s.nextLong(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextLong(10));
        assertEquals(23456, s.nextLong(10));
        assertTrue(s.hasNextLong(10));
        assertEquals(23456, s.nextLong(10));

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextLong(10));
        try {
            s.nextLong(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextLong(10));
        assertEquals(23456, s.nextLong(10));
        assertTrue(s.hasNextLong(10));
        assertEquals(23456, s.nextLong(10));

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertTrue(s.hasNextLong(10));
        assertEquals(102, s.nextLong(10));
        assertFalse(s.hasNextLong(5));
        try {
            s.nextLong(5);
            fail();
        } catch (InputMismatchException expected) {
        }
        assertTrue(s.hasNextLong(10));
        assertEquals(162, s.nextLong(10));

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        assertFalse(s.hasNextLong(10));
        try {
            s.nextLong(10);
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextLong(10));
        assertEquals(23456, s.nextLong(10));
        assertTrue(s.hasNextLong(10));
        assertEquals(23456, s.nextLong(10));

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        assertFalse(s.hasNextLong(10));
        try {
            s.nextLong(10);
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertTrue(s.hasNextLong(10));
        assertEquals(3456, s.nextLong(10));

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextLong(10));
        assertEquals(3456, s.nextLong(10));

        s = new Scanner("E34");
        assertTrue(s.hasNextLong(16));
        assertEquals(3636, s.nextLong(16));

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextLong(10));
        assertEquals(12300, s.nextLong(10));

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextLong(10));
        assertEquals(12300, s.nextLong(10));

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextLong(10));
        assertEquals(12300, s.nextLong(10));

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertTrue(s.hasNextLong(10));
        assertEquals(-123, s.nextLong(10));


        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertTrue(s.hasNextLong(10));
        assertEquals(-123, s.nextLong(10));
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextLong(int)
     */
    public void test_hasNextLongI_cache() throws IOException {
        //regression for HARMONY-2063
        s = new Scanner("123 456");
        assertTrue(s.hasNextLong(16));
        assertEquals(123, s.nextLong());
        assertEquals(456, s.nextLong());

        s = new Scanner("123 456");
        assertTrue(s.hasNextLong(16));
        assertTrue(s.hasNextLong(8));
        assertEquals(123, s.nextLong());
        assertEquals(456, s.nextLong());

        s = new Scanner("-123 -456 -789");
        assertTrue(s.hasNextLong(8));
        assertEquals(-123, s.nextInt());
        assertEquals(-456, s.nextLong());
        assertTrue(s.hasNextShort(16));
        assertEquals(-789, s.nextLong());

        s = new Scanner("123 456");
        assertTrue(s.hasNextLong());
        s.close();
        try {
            s.nextLong();
            fail();
        } catch (IllegalStateException expected) {
        }
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextLong()
     */
    public void test_hasNextLong() throws IOException {
        s = new Scanner("123 456");
        assertTrue(s.hasNextLong());
        assertEquals(123, s.nextLong());
        assertTrue(s.hasNextLong());
        assertEquals(456, s.nextLong());
        assertFalse(s.hasNextLong());
        try {
            s.nextLong();
            fail();
        } catch (NoSuchElementException expected) {
        }

        // If the radix is different from 10
        s = new Scanner("123 456");
        s.useRadix(5);
        assertTrue(s.hasNextLong());
        assertEquals(38, s.nextLong());
        assertFalse(s.hasNextLong());
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }

        // If the number is out of range
        s = new Scanner("123456789123456789123456789123456789");
        assertFalse(s.hasNextLong());
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextLong());
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.ENGLISH);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextLong());
        assertEquals(23456, s.nextLong());
        assertTrue(s.hasNextLong());
        assertEquals(23456, s.nextLong());

        /*
         * ''' is used in many locales as group separator.
         */
        s = new Scanner("23’456 23’456");
        s.useLocale(Locale.GERMANY);
        assertFalse(s.hasNextLong());
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(new Locale("it", "CH"));
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextLong());
        assertEquals(23456, s.nextLong());
        assertTrue(s.hasNextLong());
        assertEquals(23456, s.nextLong());

        /*
         * The input string has Arabic-Indic digits.
         */
        s = new Scanner("1\u06602 1\u06662");
        assertEquals(102, s.nextLong());
        s.useRadix(5);
        assertFalse(s.hasNextLong());
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useRadix(10);
        assertTrue(s.hasNextLong());
        assertEquals(162, s.nextLong());

        /*
         * '.' is used in many locales as group separator. The input string
         * has Arabic-Indic digits .
         */
        s = new Scanner("23.45\u0666 23.456");
        s.useLocale(Locale.CHINESE);
        assertFalse(s.hasNextLong());
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }
        s.useLocale(Locale.GERMANY);
        // If exception is thrown out, input will not be advanced.
        assertTrue(s.hasNextLong());
        assertEquals(23456, s.nextLong());
        assertTrue(s.hasNextLong());
        assertEquals(23456, s.nextLong());

        // The input string starts with zero
        s = new Scanner("03,456");
        s.useLocale(Locale.ENGLISH);
        assertFalse(s.hasNextLong());
        try {
            s.nextLong();
            fail();
        } catch (InputMismatchException expected) {
        }

        s = new Scanner("03456");
        assertTrue(s.hasNextLong());
        assertEquals(3456, s.nextLong());

        s = new Scanner("\u06603,456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextLong());
        assertEquals(3456, s.nextLong());

        s = new Scanner("E34");
        s.useRadix(16);
        assertTrue(s.hasNextLong());
        assertEquals(3636, s.nextLong());

        /*
         * There are 3 types of zero digit in all locales, '0' '\u0966' '\u0e50'
         * respectively, but they are not differentiated.
         */
        s = new Scanner("12300");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextLong());
        assertEquals(12300, s.nextLong());

        s = new Scanner("123\u0966\u0966");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextLong());
        assertEquals(12300, s.nextLong());

        s = new Scanner("123\u0e50\u0e50");
        s.useLocale(Locale.CHINESE);
        assertTrue(s.hasNextLong());
        assertEquals(12300, s.nextLong());

        s = new Scanner("-123");
        s.useLocale(new Locale("ar", "AE"));
        assertTrue(s.hasNextLong());
        assertEquals(-123, s.nextLong());

        s = new Scanner("-123");
        s.useLocale(new Locale("mk", "MK"));
        assertTrue(s.hasNextLong());
        assertEquals(-123, s.nextLong());
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextDouble()
     */
    public void test_hasNextDouble() throws IOException {
        s = new Scanner("123 45\u0666. 123.4 .123 ");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextDouble());
        assertEquals(123.0, s.nextDouble());
        assertTrue(s.hasNextDouble());
        assertEquals(456.0, s.nextDouble());
        assertTrue(s.hasNextDouble());
        assertEquals(123.4, s.nextDouble());
        assertTrue(s.hasNextDouble());
        assertEquals(0.123, s.nextDouble());
        assertFalse(s.hasNextDouble());
        try {
            s.nextDouble();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("+123.4 -456.7 123,456.789 0.1\u06623,4");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextDouble());
        assertEquals(123.4, s.nextDouble());
        assertTrue(s.hasNextDouble());
        assertEquals(-456.7, s.nextDouble());
        assertTrue(s.hasNextDouble());
        assertEquals(123456.789, s.nextDouble());
        assertFalse(s.hasNextDouble());
        try {
            s.nextDouble();
            fail();
        } catch (InputMismatchException expected) {
        }

        // Scientific notation
        s = new Scanner("+123.4E10 -456.7e+12 123,456.789E-10");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextDouble());
        assertEquals(1.234E12, s.nextDouble());
        assertTrue(s.hasNextDouble());
        assertEquals(-4.567E14, s.nextDouble());
        assertTrue(s.hasNextDouble());
        assertEquals(1.23456789E-5, s.nextDouble());

        s = new Scanner("NaN Infinity -Infinity");
        assertTrue(s.hasNextDouble());
        assertEquals(Double.NaN, s.nextDouble());
        assertTrue(s.hasNextDouble());
        assertEquals(Double.POSITIVE_INFINITY, s.nextDouble());
        assertTrue(s.hasNextDouble());
        assertEquals(Double.NEGATIVE_INFINITY, s.nextDouble());

        String str=String.valueOf(Double.MAX_VALUE*2);
        s=new Scanner(str);
        assertTrue(s.hasNextDouble());
        assertEquals(Double.POSITIVE_INFINITY,s.nextDouble());

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextDouble());
        assertEquals(23456.0, s.nextDouble());
        s.useLocale(Locale.GERMANY);
        assertTrue(s.hasNextDouble());
        assertEquals(23.456, s.nextDouble());

        s = new Scanner("23.456 23.456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextDouble());
        assertEquals(23.456, s.nextDouble());
        s.useLocale(Locale.GERMANY);
        assertTrue(s.hasNextDouble());
        assertEquals(23456.0, s.nextDouble());

        s = new Scanner("23,456.7 23.456,7");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextDouble());
        assertEquals(23456.7, s.nextDouble());
        s.useLocale(Locale.GERMANY);
        assertTrue(s.hasNextDouble());
        assertEquals(23456.7, s.nextDouble());

        s = new Scanner("-123.4");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextDouble());
        assertEquals(-123.4, s.nextDouble());

        s = new Scanner("+123.4 -456.7");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextDouble());
        s.close();
        try{
            s.nextDouble();
            fail();
        }catch(IllegalStateException expected) {
        }
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#hasNextBigDecimal()
     */
    public void test_hasNextBigDecimal() throws IOException {
        s = new Scanner("123 45\u0666. 123.4 .123 ");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("123"), s.nextBigDecimal());
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("456"), s.nextBigDecimal());
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("123.4"), s.nextBigDecimal());
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("0.123"), s.nextBigDecimal());
        assertFalse(s.hasNextBigDecimal());
        try {
            s.nextBigDecimal();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("+123.4 -456.7 123,456.789 0.1\u06623,4");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("123.4"), s.nextBigDecimal());
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("-456.7"), s.nextBigDecimal());
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("123456.789"), s.nextBigDecimal());
        assertFalse(s.hasNextBigDecimal());
        try {
            s.nextBigDecimal();
            fail();
        } catch (InputMismatchException expected) {
        }

        // Scientific notation
        s = new Scanner("+123.4E10 -456.7e+12 123,456.789E-10");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("1.234E12"), s.nextBigDecimal());
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("-4.567E14"), s.nextBigDecimal());
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("1.23456789E-5"), s.nextBigDecimal());

        s = new Scanner("NaN");
        assertFalse(s.hasNextBigDecimal());
        try {
            s.nextBigDecimal();
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("23456"), s.nextBigDecimal());
        s.useLocale(Locale.GERMANY);
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("23.456"), s.nextBigDecimal());

        s = new Scanner("23.456 23.456");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("23.456"), s.nextBigDecimal());
        s.useLocale(Locale.GERMANY);
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("23456"), s.nextBigDecimal());

        s = new Scanner("23,456.7");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("23456.7"), s.nextBigDecimal());

        s = new Scanner("-123.4");
        s.useLocale(Locale.ENGLISH);
        assertTrue(s.hasNextBigDecimal());
        assertEquals(new BigDecimal("-123.4"), s.nextBigDecimal());
    }

    private static class MockStringReader extends StringReader {

        public MockStringReader(String param) {
            super(param);
        }

        public int read(CharBuffer target) throws IOException {
            target.append('t');
            target.append('e');
            target.append('s');
            target.append('t');
            throw new IOException();
        }

    }

    private static class MockStringReader2Read extends StringReader {
        int timesRead = 0;

        public MockStringReader2Read(String param) {
            super(param);
        }

        public int read(CharBuffer target) throws IOException {
            if (timesRead == 0) {
                target.append('1');
                target.append('2');
                target.append('3');
                timesRead++;
                return 3;
            } else if (timesRead == 1) {
                target.append('t');
                timesRead++;
                return 1;
            } else {
                throw new IOException();
            }
        }

    }

    // https://code.google.com/p/android/issues/detail?id=40555
    public void test_40555() throws Exception {
      MockStringReader2Read reader = new MockStringReader2Read("MockStringReader");
      s = new Scanner(reader);
      // We should get a match straight away.
      String result = s.findWithinHorizon("1", 0);
      assertEquals("1", result);
      // The stream should not be consumed as there's already a match after the first read.
      assertEquals(1, reader.timesRead);
    }

    /**
     * @tests java.util.Scanner#findWithinHorizon(Pattern, int)
     */
    public void test_findWithinHorizon_LPatternI() {

        // This method searches through the input up to the specified search
        // horizon(exclusive).
        s = new Scanner("123test");
        String result = s.findWithinHorizon(Pattern.compile("\\p{Lower}"), 5);
        assertEquals("t", result);
        MatchResult mresult = s.match();
        assertEquals(3, mresult.start());
        assertEquals(4, mresult.end());

        s = new Scanner("12345test1234test next");
        /*
         * If the pattern is found the scanner advances past the input that
         * matched and returns the string that matched the pattern.
         */
        result = s.findWithinHorizon(Pattern.compile("\\p{Digit}+"), 2);
        assertEquals("12", result);
        mresult = s.match();
        assertEquals(0, mresult.start());
        assertEquals(2, mresult.end());
        // Position is now pointing at the bar. "12|345test1234test next"

        result = s.findWithinHorizon(Pattern.compile("\\p{Digit}+"), 6);
        assertEquals("345", result);

        mresult = s.match();
        assertEquals(2, mresult.start());
        assertEquals(5, mresult.end());
        // Position is now pointing at the bar. "12345|test1234test next"

        // If no such pattern is detected then the null is returned and the
        // scanner's position remains unchanged.
        result = s.findWithinHorizon(Pattern.compile("\\p{Digit}+"), 3);
        assertNull(result);

        try {
            s.match();
            fail();
        } catch (IllegalStateException expected) {
        }
        assertEquals("345", mresult.group());
        assertEquals(2, mresult.start());
        assertEquals(5, mresult.end());
        // Position is now still pointing at the bar. "12345|test1234test next"

        // If horizon is 0, then the horizon is ignored and this method
        // continues to search through the input looking for the specified
        // pattern without bound.
        result = s.findWithinHorizon(Pattern.compile("\\p{Digit}+"), 0);
        mresult = s.match();
        assertEquals(9, mresult.start());
        assertEquals(13, mresult.end());
        // Position is now pointing at the bar. "12345test1234|test next"

        assertEquals("test", s.next());
        mresult = s.match();
        assertEquals(13, mresult.start());
        assertEquals(17, mresult.end());

        assertEquals("next", s.next());
        mresult = s.match();
        assertEquals(18, mresult.start());
        assertEquals(22, mresult.end());

        try {
            s.findWithinHorizon((Pattern) null, -1);
            fail();
        } catch (NullPointerException expected) {
        }

        try {
            s.findWithinHorizon(Pattern.compile("\\p{Digit}+"), -1);
            fail();
        } catch (IllegalArgumentException expected) {
        }

        s.close();
        try {
            s.findWithinHorizon((Pattern) null, -1);
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("test");
        result = s.findWithinHorizon(Pattern.compile("\\w+"), 10);
        assertEquals("test", result);

        s = new Scanner("aa\n\rb");
        result = s.findWithinHorizon(Pattern.compile("a"), 5);
        assertEquals("a", result);
        mresult = s.match();
        assertEquals(0, mresult.start());
        assertEquals(1, mresult.end());

        result = s.findWithinHorizon(Pattern.compile("^(a)$", Pattern.MULTILINE), 5);
        assertNull(result);

        try {
            mresult = s.match();
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("");
        result = s.findWithinHorizon(Pattern.compile("^"), 0);
        assertEquals("", result);
        MatchResult matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(0, matchResult.end());

        result = s.findWithinHorizon(Pattern.compile("$"), 0);
        assertEquals("", result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(0, matchResult.end());

        s = new Scanner("1 fish 2 fish red fish blue fish");
        result = s.findWithinHorizon(Pattern
                .compile("(\\d+) fish (\\d+) fish (\\w+) fish (\\w+)"), 10);
        assertNull(result);

        try {
            mresult = s.match();
            fail();
        } catch (IllegalStateException expected) {
        }
        assertEquals(0, mresult.groupCount());

        result = s.findWithinHorizon(Pattern
                .compile("(\\d+) fish (\\d+) fish (\\w+) fish (\\w+)"), 100);
        assertEquals("1 fish 2 fish red fish blue", result);
        mresult = s.match();
        assertEquals(4, mresult.groupCount());
        assertEquals("1", mresult.group(1));
        assertEquals("2", mresult.group(2));
        assertEquals("red", mresult.group(3));
        assertEquals("blue", mresult.group(4));

        s = new Scanner("test");
        s.close();
        try {
            s.findWithinHorizon(Pattern.compile("test"), 1);
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("word1 WorD2  ");
        s.close();
        try {
            s.findWithinHorizon(Pattern.compile("\\d+"), 10);
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("word1 WorD2 wOrd3 ");
        Pattern pattern = Pattern.compile("\\d+");
        assertEquals("1", s.findWithinHorizon(pattern, 10));
        assertEquals("WorD2", s.next());
        assertEquals("3", s.findWithinHorizon(pattern, 15));

        // Regression test
        s = new Scanner(new MockStringReader("MockStringReader"));
        pattern = Pattern.compile("test");
        result = s.findWithinHorizon(pattern, 10);
        assertEquals("test", result);

        // Test the situation when input length is longer than buffer size.
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < 1026; i++) {
            stringBuilder.append('a');
        }
        s = new Scanner(stringBuilder.toString());
        pattern = Pattern.compile("\\p{Lower}+");
        result = s.findWithinHorizon(pattern, 1026);
        assertEquals(stringBuilder.toString().length(), result.length());
        assertEquals(stringBuilder.toString(), result);

        // Test the situation when input length is longer than buffer size and
        // set horizon to buffer size.
        stringBuilder = new StringBuilder();
        for (int i = 0; i < 1026; i++) {
            stringBuilder.append('a');
        }
        s = new Scanner(stringBuilder.toString());
        pattern = Pattern.compile("\\p{Lower}+");
        result = s.findWithinHorizon(pattern, 1022);
        assertEquals(1022, result.length());
        assertEquals(stringBuilder.subSequence(0, 1022), result);

        // Test the situation, under which pattern is clipped by buffer.
        stringBuilder = new StringBuilder();
        for (int i = 0; i < 1022; i++) {
            stringBuilder.append(' ');
        }
        stringBuilder.append("bbc");
        assertEquals(1025, stringBuilder.length());
        s = new Scanner(stringBuilder.toString());
        pattern = Pattern.compile("bbc");
        result = s.findWithinHorizon(pattern, 1025);
        assertEquals(3, result.length());
        assertEquals(stringBuilder.subSequence(1022, 1025), result);

        stringBuilder = new StringBuilder();
        for (int i = 0; i < 1026; i++) {
            stringBuilder.append('a');
        }
        s = new Scanner(stringBuilder.toString());
        pattern = Pattern.compile("\\p{Lower}+");
        result = s.findWithinHorizon(pattern, 0);
        assertEquals(stringBuilder.toString(), result);

        stringBuilder = new StringBuilder();
        for (int i = 0; i < 10240; i++) {
            stringBuilder.append('-');
        }
        stringBuilder.replace(0, 2, "aa");
        s = new Scanner(stringBuilder.toString());
        result = s.findWithinHorizon(Pattern.compile("aa"), 0);
        assertEquals("aa", result);

        s = new Scanner("aaaa");
        result = s.findWithinHorizon(Pattern.compile("a*"), 0);
        assertEquals("aaaa", result);
    }

    /**
     * @tests java.util.Scanner#findInLine(Pattern)
     */
    public void test_findInLine_LPattern() {

        Scanner s = new Scanner("");
        try {
            s.findInLine((Pattern) null);
            fail();
        } catch (NullPointerException expected) {
        }
        String result = s.findInLine(Pattern.compile("^"));
        assertEquals(null, result);
        result = s.findInLine(Pattern.compile("$"));
        assertEquals(null, result);

        /*
         * When we use the operation of findInLine(Pattern), the match region
         * should not span the line separator.
         */
        s = new Scanner("aa\nb.b");
        result = s.findInLine(Pattern.compile("a\nb*"));
        assertNull(result);

        s = new Scanner("aa\nbb.b");
        result = s.findInLine(Pattern.compile("\\."));
        assertNull(result);

        s = new Scanner("abcd1234test\n");
        result = s.findInLine(Pattern.compile("\\p{Lower}+"));
        assertEquals("abcd", result);
        MatchResult matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(4, matchResult.end());

        result = s.findInLine(Pattern.compile("\\p{Digit}{5}"));
        assertNull(result);
        try {
            matchResult = s.match();
            fail();
        } catch (IllegalStateException expected) {
        }
        assertEquals(0, matchResult.start());
        assertEquals(4, matchResult.end());

        result = s.findInLine(Pattern.compile("\\p{Lower}+"));
        assertEquals("test", result);
        matchResult = s.match();
        assertEquals(8, matchResult.start());
        assertEquals(12, matchResult.end());

        char[] chars = new char[2048];
        Arrays.fill(chars, 'a');
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(chars);
        stringBuilder.append("1234");
        s = new Scanner(stringBuilder.toString());
        result = s.findInLine(Pattern.compile("\\p{Digit}+"));
        assertEquals("1234", result);
        matchResult = s.match();
        assertEquals(2048, matchResult.start());
        assertEquals(2052, matchResult.end());

        s = new Scanner("test");
        s.close();
        try {
            s.findInLine((Pattern) null);
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("test1234\n1234 test");
        result = s.findInLine(Pattern.compile("test"));
        assertEquals("test", result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(4, matchResult.end());

        int number = s.nextInt();
        assertEquals(1234, number);
        matchResult = s.match();
        assertEquals(4, matchResult.start());
        assertEquals(8, matchResult.end());

        result = s.next();
        assertEquals("1234", result);
        matchResult = s.match();
        assertEquals(9, matchResult.start());
        assertEquals(13, matchResult.end());

        result = s.findInLine(Pattern.compile("test"));
        assertEquals("test", result);
        matchResult = s.match();
        assertEquals(14, matchResult.start());
        assertEquals(18, matchResult.end());

        s = new Scanner("test\u0085\ntest");
        result = s.findInLine("est");
        assertEquals("est", result);
        // First consume input upto U+0085(a line separator)
        assertTrue(s.hasNextLine());
        assertEquals("", s.nextLine());
        // Then consume input upto the "\n"
        assertTrue(s.hasNextLine());
        assertEquals("", s.nextLine());
        // The next line will be "test", which should match.
        assertEquals("est", s.findInLine("est"));

        s = new Scanner("test\ntest");
        result = s.findInLine("est");
        assertEquals("est", result);
        result = s.findInLine("est");
        assertNull(result);

        s = new Scanner("test\n123\ntest");
        result = s.findInLine("est");
        assertEquals("est", result);
        result = s.findInLine("est");
        assertNull(result);
        s.nextLine();
        result = s.findInLine("est");
        assertNull(result);
        s.nextLine();
        result = s.findInLine("est");
        assertEquals("est", result);


        s = new Scanner( "   *\n");
        result = s.findInLine(Pattern.compile( "^\\s*(?:\\*(?=[^/]))"));
        assertEquals("   *", result);
    }

    public void test_findInLine_LString_NPEs() {
        s = new Scanner("test");
        try {
            s.findInLine((String) null);
            fail();
        } catch (NullPointerException expected) {
        }
        s.close();
        try {
            s.findInLine((String) null);
            fail();
        } catch (NullPointerException expected) {
        }
        try {
            s.findInLine("test");
            fail();
        } catch (IllegalStateException expected) {
        }
    }

    public void test_findInLine_LString() {
      Scanner s = new Scanner("");
      String result = s.findInLine("^");
      assertNull(result);

      result = s.findInLine("$");
      assertNull(result);

      // When we use the operation of findInLine(Pattern), the match region
      // should not span the line separator.
      s = new Scanner("aa\nb.b");
      result = s.findInLine("a\nb*");
      assertNull(result);

      s = new Scanner("aa\nbb.b");
      result = s.findInLine("\\.");
      assertNull(result);

      s = new Scanner("abcd1234test\n");
      result = s.findInLine("\\p{Lower}+");
      assertEquals("abcd", result);
      MatchResult matchResult = s.match();
      assertEquals(0, matchResult.start());
      assertEquals(4, matchResult.end());

      result = s.findInLine("\\p{Digit}{5}");
      assertNull(result);
      try {
        matchResult = s.match();
        fail();
      } catch (IllegalStateException expected) {
      }
      assertEquals(0, matchResult.start());
      assertEquals(4, matchResult.end());

      result = s.findInLine("\\p{Lower}+");
      assertEquals("test", result);
      matchResult = s.match();
      assertEquals(8, matchResult.start());
      assertEquals(12, matchResult.end());

      char[] chars = new char[2048];
      Arrays.fill(chars, 'a');
      StringBuilder stringBuilder = new StringBuilder();
      stringBuilder.append(chars);
      stringBuilder.append("1234");
      s = new Scanner(stringBuilder.toString());
      result = s.findInLine("\\p{Digit}+");
      assertEquals("1234", result);
      matchResult = s.match();
      assertEquals(2048, matchResult.start());
      assertEquals(2052, matchResult.end());

      s = new Scanner("test1234\n1234 test");
      result = s.findInLine("test");
      assertEquals("test", result);
      matchResult = s.match();
      assertEquals(0, matchResult.start());
      assertEquals(4, matchResult.end());

      int number = s.nextInt();
      assertEquals(1234, number);
      matchResult = s.match();
      assertEquals(4, matchResult.start());
      assertEquals(8, matchResult.end());

      result = s.next();
      assertEquals("1234", result);
      matchResult = s.match();
      assertEquals(9, matchResult.start());
      assertEquals(13, matchResult.end());

      result = s.findInLine("test");
      assertEquals("test", result);
      matchResult = s.match();
      assertEquals(14, matchResult.start());
      assertEquals(18, matchResult.end());

      s = new Scanner("test\u0085\ntest");
      result = s.findInLine("est");
      assertEquals("est", result);
      result = s.findInLine("est");
      assertNull(result);

      s = new Scanner("test\ntest");
      result = s.findInLine("est");
      assertEquals("est", result);
      result = s.findInLine("est");
      assertNull(result);

      s = new Scanner("test\n123\ntest");
      result = s.findInLine("est");
      assertEquals("est", result);
      result = s.findInLine("est");
      assertNull(result);
    }

    /**
     * @tests java.util.Scanner#skip(Pattern)
     */
    public void test_skip_LPattern() {
        s = new Scanner("test");
        try {
            s.skip((String) null);
            fail();
        } catch (NullPointerException expected) {
        }

        // If pattern does not match, NoSuchElementException will be thrown out.
        s = new Scanner("1234");
        try {
            s.skip(Pattern.compile("\\p{Lower}"));
            fail();
        } catch (NoSuchElementException expected) {
        }
        // Then, no matchResult will be thrown out.
        try {
            s.match();
            fail();
        } catch (IllegalStateException expected) {
        }

        s.skip(Pattern.compile("\\p{Digit}"));
        MatchResult matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1, matchResult.end());

        s.skip(Pattern.compile("\\p{Digit}+"));
        matchResult = s.match();
        assertEquals(1, matchResult.start());
        assertEquals(4, matchResult.end());

        s.close();
        try {
            s.skip(Pattern.compile("test"));
            fail();
        } catch (IllegalStateException expected) {
        }

        MockStringReader2Read reader = new MockStringReader2Read("test");
        s = new Scanner(reader);
        try {
            s.skip(Pattern.compile("\\p{Digit}{4}"));
            fail();
        } catch (NoSuchElementException expected) {
        }
        try {
            s.match();
            fail();
        } catch (IllegalStateException expected) {
        }
        s.skip(Pattern.compile("\\p{Digit}{3}\\p{Lower}"));
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(4, matchResult.end());

        s.close();
        try {
            s.skip((Pattern) null);
            fail();
        } catch (IllegalStateException expected) {
        }

        StringBuilder stringBuilder = new StringBuilder();
        char [] chars = new char[1024];
        Arrays.fill(chars, 'a');
        stringBuilder.append(chars);
        stringBuilder.append('3');
        s = new Scanner(stringBuilder.toString());
        s.skip(Pattern.compile("\\p{Lower}+\\p{Digit}"));
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1025, matchResult.end());

        // Large amount of input may be cached
        chars = new char[102400];
        Arrays.fill(chars, 'a');
        stringBuilder = new StringBuilder();
        stringBuilder.append(chars);
        s = new Scanner(stringBuilder.toString());
        s.skip(Pattern.compile(".*"));
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(102400, matchResult.end());

        // skip something without risking a NoSuchElementException
        s.skip(Pattern.compile("[ \t]*"));
        matchResult = s.match();
        assertEquals(102400, matchResult.start());
        assertEquals(102400, matchResult.end());
    }

    /**
     * @tests java.util.Scanner#skip(String)
     */
    public void test_skip_LString() {
        s = new Scanner("test");
        try {
            s.skip((String) null);
            fail();
        } catch (NullPointerException expected) {
        }
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextDouble()
     */
    public void test_nextDouble() throws IOException {
        s = new Scanner("123 45\u0666. 123.4 .123 ");
        s.useLocale(Locale.ENGLISH);
        assertEquals(123.0, s.nextDouble());
        assertEquals(456.0, s.nextDouble());
        assertEquals(123.4, s.nextDouble());
        assertEquals(0.123, s.nextDouble());
        try {
            s.nextDouble();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("+123.4 -456.7 123,456.789 0.1\u06623,4");
        s.useLocale(Locale.ENGLISH);
        assertEquals(123.4, s.nextDouble());
        assertEquals(-456.7, s.nextDouble());
        assertEquals(123456.789, s.nextDouble());
        try {
            s.nextDouble();
            fail();
        } catch (InputMismatchException expected) {
        }

        // Scientific notation
        s = new Scanner("+123.4E10 -456.7e+12 123,456.789E-10");
        s.useLocale(Locale.ENGLISH);
        assertEquals(1.234E12, s.nextDouble());
        assertEquals(-4.567E14, s.nextDouble());
        assertEquals(1.23456789E-5, s.nextDouble());

        s = new Scanner("NaN Infinity -Infinity");
        assertEquals(Double.NaN, s.nextDouble());
        assertEquals(Double.POSITIVE_INFINITY, s.nextDouble());
        assertEquals(Double.NEGATIVE_INFINITY, s.nextDouble());

        //The following test case fails on RI
        s=new Scanner("\u221e");
        s.useLocale(Locale.ENGLISH);
        assertEquals(Double.POSITIVE_INFINITY, s.nextDouble());

        String str=String.valueOf(Double.MAX_VALUE*2);
        s=new Scanner(str);
        assertEquals(Double.POSITIVE_INFINITY,s.nextDouble());

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(23456.0, s.nextDouble());
        s.useLocale(Locale.GERMANY);
        assertEquals(23.456, s.nextDouble());

        s = new Scanner("23.456 23.456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(23.456, s.nextDouble());
        s.useLocale(Locale.GERMANY);
        assertEquals(23456.0, s.nextDouble());

        s = new Scanner("23,456.7 23.456,7");
        s.useLocale(Locale.ENGLISH);
        assertEquals(23456.7, s.nextDouble());
        s.useLocale(Locale.GERMANY);
        assertEquals(23456.7, s.nextDouble());

        s = new Scanner("-123.4");
        s.useLocale(Locale.ENGLISH);
        assertEquals(-123.4, s.nextDouble());
    }

    /**
     * @throws IOException
     * @tests java.util.Scanner#nextBigDecimal()
     */
    public void test_nextBigDecimal() throws IOException {
        s = new Scanner("123 45\u0666. 123.4 .123 ");
        s.useLocale(Locale.ENGLISH);
        assertEquals(new BigDecimal("123"), s.nextBigDecimal());
        assertEquals(new BigDecimal("456"), s.nextBigDecimal());
        assertEquals(new BigDecimal("123.4"), s.nextBigDecimal());
        assertEquals(new BigDecimal("0.123"), s.nextBigDecimal());
        try {
            s.nextBigDecimal();
            fail();
        } catch (NoSuchElementException expected) {
        }

        s = new Scanner("+123.4 -456.7 123,456.789 0.1\u06623,4");
        s.useLocale(Locale.ENGLISH);
        assertEquals(new BigDecimal("123.4"), s.nextBigDecimal());
        assertEquals(new BigDecimal("-456.7"), s.nextBigDecimal());
        assertEquals(new BigDecimal("123456.789"), s.nextBigDecimal());
        try {
            s.nextBigDecimal();
            fail();
        } catch (InputMismatchException expected) {
        }

        // Scientific notation
        s = new Scanner("+123.4E10 -456.7e+12 123,456.789E-10");
        s.useLocale(Locale.ENGLISH);
        assertEquals(new BigDecimal("1.234E12"), s.nextBigDecimal());
        assertEquals(new BigDecimal("-4.567E14"), s.nextBigDecimal());
        assertEquals(new BigDecimal("1.23456789E-5"), s.nextBigDecimal());

        s = new Scanner("NaN");
        try {
            s.nextBigDecimal();
            fail();
        } catch (InputMismatchException expected) {
        }

        /*
         * Different locale can only recognize corresponding locale sensitive
         * string. ',' is used in many locales as group separator.
         */
        s = new Scanner("23,456 23,456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(new BigDecimal("23456"), s.nextBigDecimal());
        s.useLocale(Locale.GERMANY);
        assertEquals(new BigDecimal("23.456"), s.nextBigDecimal());

        s = new Scanner("23.456 23.456");
        s.useLocale(Locale.ENGLISH);
        assertEquals(new BigDecimal("23.456"), s.nextBigDecimal());
        s.useLocale(Locale.GERMANY);
        assertEquals(new BigDecimal("23456"), s.nextBigDecimal());

        s = new Scanner("23,456.7");
        s.useLocale(Locale.ENGLISH);
        assertEquals(new BigDecimal("23456.7"), s.nextBigDecimal());

        s = new Scanner("-123.4");
        s.useLocale(Locale.ENGLISH);
        assertEquals(new BigDecimal("-123.4"), s.nextBigDecimal());
    }

    /**
     * @tests java.util.Scanner#toString()
     */
    public void test_toString() {
        s = new Scanner("test");
        assertNotNull(s.toString());
    }

    /**
     * @tests java.util.Scanner#nextLine()
     */
    public void test_nextLine() {
        s = new Scanner("");
        s.close();
        try {
            s.nextLine();
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("test\r\ntest");
        String result = s.nextLine();
        assertEquals("test", result);
        MatchResult matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(6, matchResult.end());

        s = new Scanner("\u0085");
        result = s.nextLine();
        assertEquals("", result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1, matchResult.end());

        s = new Scanner("\u2028");
        result = s.nextLine();
        assertEquals("", result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1, matchResult.end());

        s = new Scanner("\u2029");
        result = s.nextLine();
        assertEquals("", result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1, matchResult.end());

        s = new Scanner("");
        try {
            result = s.nextLine();
            fail();
        } catch (NoSuchElementException expected) {
        }
        try {
            s.match();
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("Ttest");
        result = s.nextLine();
        assertEquals("Ttest", result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(5, matchResult.end());

        s = new Scanner("\r\n");
        result = s.nextLine();
        assertEquals("", result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(2, matchResult.end());

        char[] chars = new char[1024];
        Arrays.fill(chars, 'a');
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(chars);
        chars = new char[] { '+', '-' };
        stringBuilder.append(chars);
        stringBuilder.append("\u2028");
        s = new Scanner(stringBuilder.toString());
        result = s.nextLine();

        assertEquals(stringBuilder.toString().substring(0, 1026), result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1027, matchResult.end());

        chars = new char[1023];
        Arrays.fill(chars, 'a');
        stringBuilder = new StringBuilder();
        stringBuilder.append(chars);
        stringBuilder.append("\r\n");
        s = new Scanner(stringBuilder.toString());
        result = s.nextLine();

        assertEquals(stringBuilder.toString().substring(0, 1023), result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1025, matchResult.end());

        s = new Scanner("  ");
        result = s.nextLine();
        assertEquals("  ", result);

        s = new Scanner("test\n\n\n");
        result = s.nextLine();
        assertEquals("test", result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(5, matchResult.end());
        result = s.nextLine();
        matchResult = s.match();
        assertEquals(5, matchResult.start());
        assertEquals(6, matchResult.end());

        s = new Scanner("\n\n\n");
        result = s.nextLine();
        assertEquals("", result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1, matchResult.end());
        result = s.nextLine();
        matchResult = s.match();
        assertEquals(1, matchResult.start());
        assertEquals(2, matchResult.end());

        s = new Scanner("123 test\n   ");
        int value = s.nextInt();
        assertEquals(123, value);

        result = s.nextLine();
        assertEquals(" test", result);

        s = new Scanner("test\n ");
        result = s.nextLine();
        assertEquals("test", result);

        // Regression test for Harmony-4774
        class CountReadable implements Readable {
            int counter = 0;
            public int read(CharBuffer charBuffer) throws IOException {
                counter++;
                charBuffer.append("hello\n");
                return 6;
            }
        }
        CountReadable cr = new CountReadable();
        s = new Scanner(cr);
        result = s.nextLine();
        // We expect read() to be called only once, otherwise we see the problem
        // when reading from System.in described in Harmony-4774
        assertEquals(1, cr.counter);
        assertEquals("hello", result);
    }

    /**
     * @tests java.util.Scanner#hasNextLine()
     */
    public void test_hasNextLine() {
        s = new Scanner("");
        s.close();
        try {
            s.hasNextLine();
            fail();
        } catch (IllegalStateException expected) {
        }

        s = new Scanner("test\r\ntest");
        boolean result = s.hasNextLine();
        assertTrue(result);
        MatchResult matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(6, matchResult.end());

        s = new Scanner("\u0085");
        result = s.hasNextLine();
        assertTrue(result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1, matchResult.end());

        s = new Scanner("\u2028");
        result = s.hasNextLine();
        assertTrue(result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1, matchResult.end());

        s = new Scanner("\u2029");
        result = s.hasNextLine();
        assertTrue(result);
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1, matchResult.end());

        s = new Scanner("test\n");
        assertTrue(s.hasNextLine());
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(5, matchResult.end());

        char[] chars = new char[2048];
        Arrays.fill(chars, 'a');
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(chars);
        s = new Scanner(stringBuilder.toString());
        result = s.hasNextLine();
        assertTrue(result);

        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(2048, matchResult.end());

        s = new Scanner("\n\n\n");
        assertTrue(s.hasNextLine());
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1, matchResult.end());

        // The scanner will not advance any input.
        assertTrue(s.hasNextLine());
        matchResult = s.match();
        assertEquals(0, matchResult.start());
        assertEquals(1, matchResult.end());
    }

    public void test_hasNextLine_sequence() throws IOException {
        final PipedInputStream pis = new PipedInputStream();
        final PipedOutputStream pos = new PipedOutputStream();
        final Scanner scanner = new Scanner(pis);
        pis.connect(pos);
        final List<String> result = new ArrayList<String>();
        Thread thread = new Thread(new Runnable() {
            public void run() {
                while (scanner.hasNextLine()) {
                    String line = scanner.nextLine();
                    result.add(line);
                }
            }
        });
        thread.start();
        for (int index = 0; index < 5; index++) {
            String line = "line" + index + "\n";
            pos.write(line.getBytes());
            pos.flush();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignored) {
            }
            assertEquals(index + 1, result.size());
        }
        pis.close();
        pos.close();
        try {
            thread.join(1000);
        } catch (InterruptedException ignored) {
        }
        assertFalse(scanner.hasNextLine());
    }

    protected void setUp() throws Exception {
        super.setUp();

        server = new ServerSocket(0);
        address = new InetSocketAddress("127.0.0.1", server.getLocalPort());

        client = SocketChannel.open();
        client.connect(address);
        serverSocket = server.accept();

        os = serverSocket.getOutputStream();
    }

    protected void tearDown() throws Exception {
        super.tearDown();

        try {
            serverSocket.close();
        } catch (Exception ignored) {
        }
        try {
            client.close();
        } catch (Exception ignored) {
        }
        try {
            server.close();
        } catch (Exception ignored) {
        }
    }

    // http://code.google.com/p/android/issues/detail?id=57050
    // Disable this test since it causes oom failures in follow on
    // tests. See b/160171148 for details.
    public void disableTestPerformance() throws Exception {
        int count = 100000;

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        BufferedWriter out = new BufferedWriter(new OutputStreamWriter(baos));
        for (int i = 0; i < count; ++i) {
            out.write("123 ");
        }
        out.close();

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        bais.mark(-1);

        Scanner s = new Scanner(new BufferedReader(new InputStreamReader(bais)));
        for (int i = 0; i < count; ++i) {
            final int value;
            try {
                value = s.nextInt();
            } catch (RuntimeException e) {
                String msg = String.format(Locale.US,
                        "Failed to parse float on item %d/%d with locale %s: %s",
                        (i+1), count, s.locale(), s);
                throw new RuntimeException(msg, e);
            }
            if (value != 123) {
                fail();
            }
        }

        bais.reset();
        s = new Scanner(new BufferedReader(new InputStreamReader(bais)));
        for (int i = 0; i < count; ++i) {
            final float value;
            try {
                value = s.nextFloat();
            } catch (RuntimeException e) {
                String msg = String.format(Locale.US,
                        "Failed to parse float on item %d/%d with locale %s: %s",
                        (i+1), count, s.locale(), s);
                throw new RuntimeException(msg, e);
            }
            if (value != 123.0) {
                fail();
            }
        }
        System.gc();
    }
}