xref: /dalvik/libcore/luni/src/test/java/tests/api/java/io/StreamTokenizerTest.java

/*
 *  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 tests.api.java.io;

import java.io.ByteArrayInputStream;
import java.io.CharArrayReader;
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.Reader;
import java.io.StreamTokenizer;
import java.io.StringBufferInputStream;
import java.io.StringReader;

import junit.framework.Assert;
import tests.support.Support_StringReader;
import tests.support.Support_ASimpleInputStream;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargets;
// TODO: most of the assertTrue calls in this test case should be
// replaced with assertEquals (possibly two assertEquals) see
// test_ConstructorLjava_io_InputStream for example.
// This gives much more helpful error messages.

@TestTargetClass(StreamTokenizer.class)
public class StreamTokenizerTest extends junit.framework.TestCase {
    Support_StringReader r;

    StreamTokenizer st;

    String testString;

    /**
     * @tests java.io.StreamTokenizer#StreamTokenizer(java.io.InputStream)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "StreamTokenizer",
        args = {java.io.InputStream.class}
    )
    public void test_ConstructorLjava_io_InputStream() throws IOException {
        st = new StreamTokenizer(new StringBufferInputStream(
                "/comments\n d 8 'h'"));

        assertEquals("the next token returned should be the letter d",
                 StreamTokenizer.TT_WORD, st.nextToken());
        assertEquals("the next token returned should be the letter d",
                 "d", st.sval);

        assertEquals("the next token returned should be the digit 8",
                 StreamTokenizer.TT_NUMBER, st.nextToken());
        assertEquals("the next token returned should be the digit 8",
                 8.0, st.nval);

        assertEquals("the next token returned should be the quote character",
                 39, st.nextToken());
        assertEquals("the next token returned should be the quote character",
                 "h", st.sval);
    }

    /**
     * @tests java.io.StreamTokenizer#StreamTokenizer(java.io.Reader)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "StreamTokenizer",
        args = {java.io.Reader.class}
    )
    public void test_ConstructorLjava_io_Reader() throws IOException {
        setTest("/testing\n d 8 'h' ");
        assertEquals("the next token returned should be the letter d skipping the comments",
                 StreamTokenizer.TT_WORD, st.nextToken());
        assertEquals("the next token returned should be the letter d",
                 "d", st.sval);

        assertEquals("the next token returned should be the digit 8",
                 StreamTokenizer.TT_NUMBER, st.nextToken());
        assertEquals("the next token returned should be the digit 8",
                 8.0, st.nval);

        assertEquals("the next token returned should be the quote character",
                 39, st.nextToken());
        assertEquals("the next token returned should be the quote character",
                 "h", st.sval);
    }

    /**
     * @tests java.io.StreamTokenizer#commentChar(int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "commentChar",
        args = {int.class}
    )
    public void test_commentCharI() throws IOException {
        setTest("*comment \n / 8 'h' ");
        st.ordinaryChar('/');
        st.commentChar('*');
        assertEquals("nextToken() did not return the character / skiping the comments starting with *",
                 47, st.nextToken());
        assertTrue("the next token returned should be the digit 8", st
               .nextToken() == StreamTokenizer.TT_NUMBER
               && st.nval == 8.0);
        assertTrue("the next token returned should be the quote character",
               st.nextToken() == 39 && st.sval.equals("h"));
    }

    /**
     * @tests java.io.StreamTokenizer#eolIsSignificant(boolean)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "eolIsSignificant",
        args = {boolean.class}
    )
    public void test_eolIsSignificantZ() throws IOException {
        setTest("d 8\n");
        // by default end of line characters are not significant
        assertTrue("nextToken did not return d",
               st.nextToken() == StreamTokenizer.TT_WORD
               && st.sval.equals("d"));
        assertTrue("nextToken did not return 8",
               st.nextToken() == StreamTokenizer.TT_NUMBER
               && st.nval == 8.0);
        assertTrue("nextToken should be the end of file",
               st.nextToken() == StreamTokenizer.TT_EOF);
        setTest("d\n");
        st.eolIsSignificant(true);
        // end of line characters are significant
        assertTrue("nextToken did not return d",
               st.nextToken() == StreamTokenizer.TT_WORD
               && st.sval.equals("d"));
        assertTrue("nextToken is the end of line",
               st.nextToken() == StreamTokenizer.TT_EOL);
    }

    /**
     * @tests java.io.StreamTokenizer#lineno()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "lineno",
        args = {}
    )
    public void test_lineno() throws IOException {
        setTest("d\n 8\n");
        assertEquals("the lineno should be 1", 1, st.lineno());
        st.nextToken();
        st.nextToken();
        assertEquals("the lineno should be 2", 2, st.lineno());
        st.nextToken();
        assertEquals("the next line no should be 3", 3, st.lineno());
    }

    /**
     * @tests java.io.StreamTokenizer#lowerCaseMode(boolean)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "lowerCaseMode",
        args = {boolean.class}
    )
    public void test_lowerCaseModeZ() throws Exception {
        // SM.
        setTest("HELLOWORLD");
        st.lowerCaseMode(true);

        st.nextToken();
        assertEquals("sval not converted to lowercase.", "helloworld", st.sval
                 );
    }

    /**
     * @tests java.io.StreamTokenizer#nextToken()
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        method = "nextToken",
        args = {}
    )
    public void test_nextToken() throws IOException {
        setTest("\r\n/* fje fje 43.4 f \r\n f g */  456.459 \r\n"
                + "Hello  /     \r\n \r\n \n \r \257 Hi \'Hello World\'");
        st.ordinaryChar('/');
        st.slashStarComments(true);
        st.nextToken();
        assertTrue("Wrong Token type1: " + (char) st.ttype,
               st.ttype == StreamTokenizer.TT_NUMBER);
        st.nextToken();
        assertTrue("Wrong Token type2: " + st.ttype,
               st.ttype == StreamTokenizer.TT_WORD);
        st.nextToken();
        assertTrue("Wrong Token type3: " + st.ttype, st.ttype == '/');
        st.nextToken();
        assertTrue("Wrong Token type4: " + st.ttype,
               st.ttype == StreamTokenizer.TT_WORD);
        st.nextToken();
        assertTrue("Wrong Token type5: " + st.ttype,
               st.ttype == StreamTokenizer.TT_WORD);
        st.nextToken();
        assertTrue("Wrong Token type6: " + st.ttype, st.ttype == '\'');
        assertTrue("Wrong Token type7: " + st.ttype, st.sval
               .equals("Hello World"));
        st.nextToken();
        assertTrue("Wrong Token type8: " + st.ttype, st.ttype == -1);

        final PipedInputStream pin = new PipedInputStream();
        PipedOutputStream pout = new PipedOutputStream(pin);
        pout.write("hello\n\r\r".getBytes());
        st = new StreamTokenizer(pin);
        st.eolIsSignificant(true);
        assertTrue("Wrong token 1,1",
               st.nextToken() == StreamTokenizer.TT_WORD
               && st.sval.equals("hello"));
        assertTrue("Wrong token 1,2", st.nextToken() == '\n');
        assertTrue("Wrong token 1,3", st.nextToken() == '\n');
        assertTrue("Wrong token 1,4", st.nextToken() == '\n');
        pout.close();
        assertTrue("Wrong token 1,5",
               st.nextToken() == StreamTokenizer.TT_EOF);

        st = new StreamTokenizer(new Support_StringReader("\n \r\n#"));
        st.ordinaryChar('\n'); // make \n ordinary
        st.eolIsSignificant(true);
        assertTrue("Wrong token 2,1", st.nextToken() == '\n');
        assertTrue("Wrong token 2,2", st.nextToken() == '\n');
        assertEquals("Wrong token 2,3", '#', st.nextToken());

        Support_ASimpleInputStream sis = new Support_ASimpleInputStream();
        sis.throwExceptionOnNextUse = true;
        st = new StreamTokenizer(sis);
        try {
            st.nextToken();
            fail("IOException expected.");
        } catch (IOException e) {
            // Expected.
        }
    }

    /**
     * @tests java.io.StreamTokenizer#ordinaryChar(int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "ordinaryChar",
        args = {int.class}
    )
    public void test_ordinaryCharI() throws IOException {
        // SM.
        setTest("Ffjein 893");
        st.ordinaryChar('F');
        st.nextToken();
        assertTrue("OrdinaryChar failed." + (char) st.ttype,
               st.ttype == 'F');
    }

    /**
     * @tests java.io.StreamTokenizer#ordinaryChars(int, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "ordinaryChars",
        args = {int.class, int.class}
    )
    public void test_ordinaryCharsII() throws IOException {
        // SM.
        setTest("azbc iof z 893");
        st.ordinaryChars('a', 'z');
        assertEquals("OrdinaryChars failed.", 'a', st.nextToken());
        assertEquals("OrdinaryChars failed.", 'z', st.nextToken());
    }

    /**
     * @tests java.io.StreamTokenizer#parseNumbers()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "parseNumbers",
        args = {}
    )
    public void test_parseNumbers() throws IOException {
        // SM
        setTest("9.9 678");
        assertTrue("Base behavior failed.",
               st.nextToken() == StreamTokenizer.TT_NUMBER);
        st.ordinaryChars('0', '9');
        assertEquals("setOrdinary failed.", '6', st.nextToken());
        st.parseNumbers();
        assertTrue("parseNumbers failed.",
               st.nextToken() == StreamTokenizer.TT_NUMBER);
    }

    /**
     * @tests java.io.StreamTokenizer#pushBack()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "pushBack",
        args = {}
    )
    public void test_pushBack() throws IOException {
        // SM.
        setTest("Hello 897");
        st.nextToken();
        st.pushBack();
        assertTrue("PushBack failed.",
               st.nextToken() == StreamTokenizer.TT_WORD);
    }

    /**
     * @tests java.io.StreamTokenizer#quoteChar(int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "quoteChar",
        args = {int.class}
    )
    public void test_quoteCharI() throws IOException {
        // SM
        setTest("<Hello World<    HelloWorldH");
        st.quoteChar('<');
        assertEquals("QuoteChar failed.", '<', st.nextToken());
        assertEquals("QuoteChar failed.", "Hello World", st.sval);
        st.quoteChar('H');
        st.nextToken();
        assertEquals("QuoteChar failed for word.", "elloWorld", st.sval
                 );
    }

    /**
     * @tests java.io.StreamTokenizer#resetSyntax()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "resetSyntax",
        args = {}
    )
    public void test_resetSyntax() throws IOException {
        // SM
        setTest("H 9\' ello World");
        st.resetSyntax();
        assertTrue("resetSyntax failed1." + (char) st.ttype,
               st.nextToken() == 'H');
        assertTrue("resetSyntax failed1." + (char) st.ttype,
               st.nextToken() == ' ');
        assertTrue("resetSyntax failed2." + (char) st.ttype,
               st.nextToken() == '9');
        assertTrue("resetSyntax failed3." + (char) st.ttype,
               st.nextToken() == '\'');
    }

    /**
     * @tests java.io.StreamTokenizer#slashSlashComments(boolean)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "slashSlashComments",
        args = {boolean.class}
    )
    public void test_slashSlashCommentsZ() throws IOException {
        // SM.
        setTest("// foo \r\n /fiji \r\n -456");
        st.ordinaryChar('/');
        st.slashSlashComments(true);
        assertEquals("Test failed.", '/', st.nextToken());
        assertTrue("Test failed.",
               st.nextToken() == StreamTokenizer.TT_WORD);
    }

    /**
     * @tests java.io.StreamTokenizer#slashSlashComments(boolean)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL,
        notes = "",
        method = "slashSlashComments",
        args = {boolean.class}
    )
    public void test_slashSlashComments_withSSOpen() throws IOException {
        Reader reader = new CharArrayReader( "t // t t t".toCharArray());

        StreamTokenizer st = new StreamTokenizer(reader);
        st.slashSlashComments(true);

        assertEquals(StreamTokenizer.TT_WORD,st.nextToken());
        assertEquals(StreamTokenizer.TT_EOF,st.nextToken());
    }

    /**
     * @tests java.io.StreamTokenizer#slashSlashComments(boolean)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL,
        notes = "",
        method = "slashSlashComments",
        args = {boolean.class}
    )
    public void test_slashSlashComments_withSSOpen_NoComment() throws IOException {
        Reader reader = new CharArrayReader( "// t".toCharArray());

        StreamTokenizer st = new StreamTokenizer(reader);
        st.slashSlashComments(true);
        st.ordinaryChar('/');

        assertEquals(StreamTokenizer.TT_EOF,st.nextToken());
    }

    /**
     * @tests java.io.StreamTokenizer#slashSlashComments(boolean)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL,
        notes = "",
        method = "slashSlashComments",
        args = {boolean.class}
    )
    public void test_slashSlashComments_withSSClosed() throws IOException {
        Reader reader = new CharArrayReader( "// t".toCharArray());

        StreamTokenizer st = new StreamTokenizer(reader);
        st.slashSlashComments(false);
        st.ordinaryChar('/');

        assertEquals('/',st.nextToken());
        assertEquals('/',st.nextToken());
        assertEquals(StreamTokenizer.TT_WORD,st.nextToken());
    }

    /**
     * @tests java.io.StreamTokenizer#slashStarComments(boolean)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "slashStarComments",
        args = {boolean.class}
    )
    public void test_slashStarCommentsZ() throws IOException {
        setTest("/* foo \r\n /fiji \r\n*/ -456");
        st.ordinaryChar('/');
        st.slashStarComments(true);
        assertTrue("Test failed.",
               st.nextToken() == StreamTokenizer.TT_NUMBER);
    }

    /**
     * @tests java.io.StreamTokenizer#slashStarComments(boolean)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL,
        notes = "",
        method = "slashStarComments",
        args = {boolean.class}
    )
    public void test_slashStarComments_withSTOpen() throws IOException {
        Reader reader = new CharArrayReader( "t /* t */ t".toCharArray());

        StreamTokenizer st = new StreamTokenizer(reader);
        st.slashStarComments(true);

        assertEquals(StreamTokenizer.TT_WORD,st.nextToken());
        assertEquals(StreamTokenizer.TT_WORD,st.nextToken());
        assertEquals(StreamTokenizer.TT_EOF,st.nextToken());
    }

    /**
     * @tests java.io.StreamTokenizer#slashStarComments(boolean)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL,
        notes = "",
        method = "slashStarComments",
        args = {boolean.class}
    )
    public void test_slashStarComments_withSTClosed() throws IOException {
        Reader reader = new CharArrayReader( "t /* t */ t".toCharArray());

        StreamTokenizer st = new StreamTokenizer(reader);
        st.slashStarComments(false);

        assertEquals(StreamTokenizer.TT_WORD,st.nextToken());
        assertEquals(StreamTokenizer.TT_EOF,st.nextToken());
    }

    /**
     * @tests java.io.StreamTokenizer#toString()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "toString",
        args = {}
    )
    public void test_toString() throws IOException {
        setTest("ABC Hello World");
        st.nextToken();
        assertTrue("toString failed." + st.toString(),
               st.toString().equals(
                        "Token[ABC], line 1"));
    }

    /**
     * @tests java.io.StreamTokenizer#whitespaceChars(int, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "whitespaceChars",
        args = {int.class, int.class}
    )
    public void test_whitespaceCharsII() throws IOException {
        setTest("azbc iof z 893");
        st.whitespaceChars('a', 'z');
        assertTrue("OrdinaryChar failed.",
               st.nextToken() == StreamTokenizer.TT_NUMBER);
    }

    /**
     * @tests java.io.StreamTokenizer#wordChars(int, int)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "wordChars",
        args = {int.class, int.class}
    )
    public void test_wordCharsII() throws IOException {
        setTest("A893 -9B87");
        st.wordChars('0', '9');
        assertTrue("WordChar failed1.",
               st.nextToken() == StreamTokenizer.TT_WORD);
        assertEquals("WordChar failed2.", "A893", st.sval);
        assertTrue("WordChar failed3.",
               st.nextToken() == StreamTokenizer.TT_NUMBER);
        st.nextToken();
        assertEquals("WordChar failed4.", "B87", st.sval);

        setTest("    Hello World");
        st.wordChars(' ', ' ');
        st.nextToken();
        assertEquals("WordChars failed for whitespace.", "Hello World", st.sval
                 );

        setTest("    Hello World\r\n  \'Hello World\' Hello\' World");
        st.wordChars(' ', ' ');
        st.wordChars('\'', '\'');
        st.nextToken();
        assertTrue("WordChars failed for whitespace: " + st.sval, st.sval
               .equals("Hello World"));
        st.nextToken();
        assertTrue("WordChars failed for quote1: " + st.sval, st.sval
               .equals("\'Hello World\' Hello\' World"));
    }

    private void setTest(String s) {
        testString = s;
        r = new Support_StringReader(testString);
        st = new StreamTokenizer(r);
    }

    protected void setUp() {
    }

    protected void tearDown() {
    }

    @TestTargets({
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "General functionality of these methods tested in separate tests.",
            method = "lineno",
            args = {}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL_COMPLETE,
            notes = "General functionality of these methods tested in separate tests.",
            method = "nextToken",
            args = {}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "General functionality of these methods tested in separate tests.",
            method = "toString",
            args = {}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "General functionality of these methods tested in separate tests.",
            method = "commentChar",
            args = {int.class}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "General functionality of these methods tested in separate tests.",
            method = "eolIsSignificant",
            args = {boolean.class}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "General functionality of these methods tested in separate tests.",
            method = "lowerCaseMode",
            args = {boolean.class}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "General functionality of these methods tested in separate tests.",
            method = "ordinaryChar",
            args = {int.class}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "General functionality of these methods tested in separate tests.",
            method = "slashStarComments",
            args = {boolean.class}
        )
    })
    public void test_basicStringTokenizerMethods()
    {
        String str = "Testing 12345 \n alpha \r\n omega";
        String strb = "-3.8 'BLIND mice' \r sEe /* how */ they run";
        StringReader aa = new StringReader(str);
        StringReader ba = new StringReader(strb);
        StreamTokenizer a = new StreamTokenizer(aa);
        StreamTokenizer b = new StreamTokenizer(ba);

        try {
            Assert.assertTrue(a.lineno() == 1);
            Assert.assertTrue(a.nextToken() == StreamTokenizer.TT_WORD);
            Assert.assertTrue(a.toString().equals("Token[Testing], line 1"));
            Assert.assertTrue(a.nextToken() == StreamTokenizer.TT_NUMBER);
            Assert.assertTrue(a.toString().equals("Token[n=12345.0], line 1"));
            Assert.assertTrue(a.nextToken() == StreamTokenizer.TT_WORD);
            Assert.assertTrue(a.toString().equals("Token[alpha], line 2"));
            Assert.assertTrue(a.nextToken() == StreamTokenizer.TT_WORD);
            Assert.assertTrue(a.toString().equals("Token[omega], line 3"));
            Assert.assertTrue(a.nextToken() == StreamTokenizer.TT_EOF);
            Assert.assertTrue(a.toString().equals("Token[EOF], line 3"));

            b.commentChar('u');
            b.eolIsSignificant(true);
            b.lowerCaseMode(true);
            b.ordinaryChar('y');
            b.slashStarComments(true);

            Assert.assertTrue(b.nextToken() == StreamTokenizer.TT_NUMBER);
            Assert.assertTrue(b.nval == -3.8);
            Assert.assertTrue(b.toString().equals("Token[n=-3.8], line 1"));
            Assert.assertTrue(b.nextToken() == 39); // '
            Assert.assertTrue(b.toString().equals("Token[BLIND mice], line 1"));
            Assert.assertTrue(b.nextToken() == 10); // \n
            Assert.assertTrue(b.toString().equals("Token[EOL], line 2"));
            Assert.assertTrue(b.nextToken() == StreamTokenizer.TT_WORD);
            Assert.assertTrue(b.toString().equals("Token[see], line 2"));
            Assert.assertTrue(b.nextToken() == StreamTokenizer.TT_WORD);
            Assert.assertTrue(b.toString().equals("Token[the], line 2"));
            Assert.assertTrue(b.nextToken() == 121); // y
            Assert.assertTrue(b.toString().equals("Token['y'], line 2"));
            Assert.assertTrue(b.nextToken() == StreamTokenizer.TT_WORD);
            Assert.assertTrue(b.toString().equals("Token[r], line 2"));
            Assert.assertTrue(b.nextToken() == StreamTokenizer.TT_EOF);
            Assert.assertTrue(b.toString().equals("Token[EOF], line 2"));
        }
        catch (Exception ex){
            System.out.println("Exception found in StreamTokenizer");
            ex.printStackTrace();
            throw new RuntimeException("error in test, see stdout");
        }
    }

    @TestTargets({
        @TestTargetNew(
            level = TestLevel.PARTIAL_COMPLETE,
            notes = "",
            method = "nextToken",
            args = {}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "",
            method = "toString",
            args = {}
        )
    })
    public void test_harmonyRegressionTest() {
        byte[] data = new byte[] {(byte) '-'};
        StreamTokenizer tokenizer = new StreamTokenizer(new ByteArrayInputStream(data));
        try {
            tokenizer.nextToken();
        } catch(Exception e) {
            Assert.fail(e.getMessage());
        }
        String result = tokenizer.toString();
        Assert.assertEquals("Token['-'], line 1", result);
    }

    @TestTargets({
        @TestTargetNew(
            level = TestLevel.PARTIAL_COMPLETE,
            notes = "",
            method = "nextToken",
            args = {}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL,
            notes = "",
            method = "toString",
            args = {}
        )
    })
    public void test_harmonyRegressionTest2() {
        byte[] data = new byte[] {(byte) '"',
                                  (byte) 'H',
                                  (byte) 'e',
                                  (byte) 'l',
                                  (byte) 'l',
                                  (byte) 'o',
                                  (byte) '"'};
        StreamTokenizer tokenizer = new StreamTokenizer(new ByteArrayInputStream(data));
        try {
            tokenizer.nextToken();
        } catch (Exception e) {
            e.printStackTrace();
        }
        String result = tokenizer.toString();
        Assert.assertEquals("Token[Hello], line 1", result);
    }
}