/*
* 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.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 tests.support.Support_StringReader;
public class StreamTokenizerTest extends junit.framework.TestCase {
Support_StringReader r;
StreamTokenizer st;
String testString;
/**
* java.io.StreamTokenizer#StreamTokenizer(java.io.InputStream)
*/
@SuppressWarnings("deprecation")
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);
}
/**
* java.io.StreamTokenizer#StreamTokenizer(java.io.Reader)
*/
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);
}
/**
* java.io.StreamTokenizer#commentChar(int)
*/
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"));
}
/**
* java.io.StreamTokenizer#eolIsSignificant(boolean)
*/
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);
}
/**
* java.io.StreamTokenizer#lineno()
*/
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());
}
/**
* java.io.StreamTokenizer#lowerCaseMode(boolean)
*/
public void test_lowerCaseModeZ() throws Exception {
// SM.
setTest("HELLOWORLD");
st.lowerCaseMode(true);
st.nextToken();
assertEquals("sval not converted to lowercase.", "helloworld", st.sval
);
}
/**
* java.io.StreamTokenizer#nextToken()
*/
@SuppressWarnings("deprecation")
public void test_nextToken() throws IOException {
// SM.
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("UTF-8"));
StreamTokenizer s = new StreamTokenizer(pin);
s.eolIsSignificant(true);
assertTrue("Wrong token 1,1",
s.nextToken() == StreamTokenizer.TT_WORD
&& s.sval.equals("hello"));
assertTrue("Wrong token 1,2", s.nextToken() == '\n');
assertTrue("Wrong token 1,3", s.nextToken() == '\n');
assertTrue("Wrong token 1,4", s.nextToken() == '\n');
pout.close();
assertTrue("Wrong token 1,5",
s.nextToken() == StreamTokenizer.TT_EOF);
StreamTokenizer tokenizer = new StreamTokenizer(
new Support_StringReader("\n \r\n#"));
tokenizer.ordinaryChar('\n'); // make \n ordinary
tokenizer.eolIsSignificant(true);
assertTrue("Wrong token 2,1", tokenizer.nextToken() == '\n');
assertTrue("Wrong token 2,2", tokenizer.nextToken() == '\n');
assertEquals("Wrong token 2,3", '#', tokenizer.nextToken());
}
/**
* java.io.StreamTokenizer#ordinaryChar(int)
*/
public void test_ordinaryCharI() throws IOException {
// SM.
setTest("Ffjein 893");
st.ordinaryChar('F');
st.nextToken();
assertTrue("OrdinaryChar failed." + (char) st.ttype,
st.ttype == 'F');
}
/**
* java.io.StreamTokenizer#ordinaryChars(int, int)
*/
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());
}
/**
* java.io.StreamTokenizer#parseNumbers()
*/
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);
}
/**
* java.io.StreamTokenizer#pushBack()
*/
public void test_pushBack() throws IOException {
// SM.
setTest("Hello 897");
st.nextToken();
st.pushBack();
assertTrue("PushBack failed.",
st.nextToken() == StreamTokenizer.TT_WORD);
}
/**
* java.io.StreamTokenizer#quoteChar(int)
*/
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
);
}
/**
* java.io.StreamTokenizer#resetSyntax()
*/
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() == '\'');
}
/**
* java.io.StreamTokenizer#slashSlashComments(boolean)
*/
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);
}
/**
* java.io.StreamTokenizer#slashSlashComments(boolean)
*/
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());
}
/**
* java.io.StreamTokenizer#slashSlashComments(boolean)
*/
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());
}
/**
* java.io.StreamTokenizer#slashSlashComments(boolean)
*/
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());
}
/**
* java.io.StreamTokenizer#slashStarComments(boolean)
*/
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);
}
/**
* java.io.StreamTokenizer#slashStarComments(boolean)
*/
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());
}
/**
* java.io.StreamTokenizer#slashStarComments(boolean)
*/
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());
}
/**
* java.io.StreamTokenizer#toString()
*/
public void test_toString() throws IOException {
setTest("ABC Hello World");
st.nextToken();
assertTrue("toString failed." + st.toString(),
st.toString().equals(
"Token[ABC], line 1"));
// Regression test for HARMONY-4070
byte[] data = new byte[] { (byte) '-' };
StreamTokenizer tokenizer = new StreamTokenizer(
new ByteArrayInputStream(data));
tokenizer.nextToken();
String result = tokenizer.toString();
assertEquals("Token['-'], line 1", result);
}
/**
* java.io.StreamTokenizer#whitespaceChars(int, int)
*/
public void test_whitespaceCharsII() throws IOException {
setTest("azbc iof z 893");
st.whitespaceChars('a', 'z');
assertTrue("OrdinaryChar failed.",
st.nextToken() == StreamTokenizer.TT_NUMBER);
}
/**
* java.io.StreamTokenizer#wordChars(int, int)
*/
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() {
}
}