/*
* Reference ETL Parser for Java
* Copyright (c) 2000-2009 Constantine A Plotnikov
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package net.sf.etl.tests.term_parser;
import java.io.StringReader;
import java.net.URL;
import junit.framework.TestCase;
import net.sf.etl.parsers.ObjectName;
import net.sf.etl.parsers.PropertyName;
import net.sf.etl.parsers.StandardGrammars;
import net.sf.etl.parsers.TermParser;
import net.sf.etl.parsers.TermParserFactory;
import net.sf.etl.parsers.Terms;
import org.xml.sax.InputSource;
/**
* This is a test for default grammar.
*
* @author const
*
*/
public class DefautGrammarTest extends TestCase {
/**
* a phrase parser used in the test case
*/
TermParser parser;
/**
* start parsing resource
*
* @param resourceName
* name of resource
*/
protected void startWithResource(String resourceName) {
final URL in = this.getClass().getResource(resourceName);
assertNotNull(in);
parser = TermParserFactory.newInstance().newTermParser();
parser.parse(new InputSource(in.toString()));
parser.advance();
}
/**
* start parsing resource
*
* @param systemId
* a system id
* @param text
* a text
*/
protected void startWithString(String systemId, String text) {
parser = TermParserFactory.newInstance().newTermParser();
final InputSource s = new InputSource(new StringReader(text));
s.setSystemId(systemId);
parser.parse(s);
parser.advance();
}
/**
* skip ignorable
*/
protected void skipIgnorable() {
while (true) {
switch (parser.current().kind()) {
case OBJECT_START:
case OBJECT_END:
case LIST_PROPERTY_START:
case LIST_PROPERTY_END:
case PROPERTY_START:
case PROPERTY_END:
case VALUE:
case EOF:
return;
default:
parser.advance();
}
}
}
/**
* Expect object start/end
*
* @param kind
* a kind of event
* @param name
* a object name
*/
protected void expectObject(Terms kind, ObjectName name) {
skipIgnorable();
assertSame("checking: " + parser.current(), kind, parser.current()
.kind());
assertEquals("checking: " + parser.current(), name, parser.current()
.objectName());
parser.advance();
}
/**
* Expect single value property
*
* @param name
* a name to expect
* @param value
* a value to expect
*/
protected void expectValueProp(PropertyName name, String value) {
expectProperty(Terms.PROPERTY_START, name);
expectValue(value);
expectProperty(Terms.PROPERTY_END, name);
}
/**
* Expect property
*
* @param kind
* a kind of event
* @param name
* a name of property
*/
protected void expectProperty(Terms kind, PropertyName name) {
skipIgnorable();
assertSame("checking: " + parser.current(), kind, parser.current()
.kind());
assertEquals("checking: " + parser.current(), name, parser.current()
.propertyName());
parser.advance();
}
/**
* Expected value
*
* @param text
* a text of value
*/
protected void expectValue(String text) {
skipIgnorable();
assertSame("checking: " + parser.current(), Terms.VALUE, parser
.current().kind());
assertEquals("checking: " + parser.current(), text, parser.current()
.token().token().text());
parser.advance();
}
/**
* Expect EOF
*/
protected void expectEof() {
skipIgnorable();
assertSame("checking: " + parser.current(), Terms.EOF, parser.current()
.kind());
parser.advance();
}
/**
* Run simple empty block test
*/
public void testEmptyBlock() {
startWithString("none", "{};");
expectObject(Terms.OBJECT_START,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT);
expectProperty(Terms.LIST_PROPERTY_START,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT_CONTENT);
expectObject(Terms.OBJECT_START, StandardGrammars.DEFAULT_GRAMMAR_BLOCK);
expectProperty(Terms.LIST_PROPERTY_START,
StandardGrammars.DEFAULT_GRAMMAR_BLOCK_CONTENT);
expectProperty(Terms.LIST_PROPERTY_END,
StandardGrammars.DEFAULT_GRAMMAR_BLOCK_CONTENT);
expectObject(Terms.OBJECT_END, StandardGrammars.DEFAULT_GRAMMAR_BLOCK);
expectProperty(Terms.LIST_PROPERTY_END,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT_CONTENT);
expectObject(Terms.OBJECT_END,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT);
expectEof();
}
/**
* A simple no doctype text
*/
public void testNoDoctype() {
startWithString("none", "a b c; {q {};};");
// first statement
expectObject(Terms.OBJECT_START,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT);
expectProperty(Terms.LIST_PROPERTY_START,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT_CONTENT);
expectObject(Terms.OBJECT_START,
StandardGrammars.DEFAULT_GRAMMAR_TOKENS);
expectProperty(Terms.LIST_PROPERTY_START,
StandardGrammars.DEFAULT_GRAMMAR_TOKENS_VALUES);
expectValue("a");
expectValue("b");
expectValue("c");
expectProperty(Terms.LIST_PROPERTY_END,
StandardGrammars.DEFAULT_GRAMMAR_TOKENS_VALUES);
expectObject(Terms.OBJECT_END, StandardGrammars.DEFAULT_GRAMMAR_TOKENS);
expectProperty(Terms.LIST_PROPERTY_END,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT_CONTENT);
expectObject(Terms.OBJECT_END,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT);
// second statement
expectObject(Terms.OBJECT_START,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT);
expectProperty(Terms.LIST_PROPERTY_START,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT_CONTENT);
{
expectObject(Terms.OBJECT_START,
StandardGrammars.DEFAULT_GRAMMAR_BLOCK);
expectProperty(Terms.LIST_PROPERTY_START,
StandardGrammars.DEFAULT_GRAMMAR_BLOCK_CONTENT);
{
expectObject(Terms.OBJECT_START,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT);
expectProperty(Terms.LIST_PROPERTY_START,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT_CONTENT);
{
expectObject(Terms.OBJECT_START,
StandardGrammars.DEFAULT_GRAMMAR_TOKENS);
expectProperty(Terms.LIST_PROPERTY_START,
StandardGrammars.DEFAULT_GRAMMAR_TOKENS_VALUES);
expectValue("q");
expectProperty(Terms.LIST_PROPERTY_END,
StandardGrammars.DEFAULT_GRAMMAR_TOKENS_VALUES);
expectObject(Terms.OBJECT_END,
StandardGrammars.DEFAULT_GRAMMAR_TOKENS);
expectObject(Terms.OBJECT_START,
StandardGrammars.DEFAULT_GRAMMAR_BLOCK);
expectProperty(Terms.LIST_PROPERTY_START,
StandardGrammars.DEFAULT_GRAMMAR_BLOCK_CONTENT);
expectProperty(Terms.LIST_PROPERTY_END,
StandardGrammars.DEFAULT_GRAMMAR_BLOCK_CONTENT);
expectObject(Terms.OBJECT_END,
StandardGrammars.DEFAULT_GRAMMAR_BLOCK);
}
expectProperty(Terms.LIST_PROPERTY_END,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT_CONTENT);
expectObject(Terms.OBJECT_END,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT);
}
expectProperty(Terms.LIST_PROPERTY_END,
StandardGrammars.DEFAULT_GRAMMAR_BLOCK_CONTENT);
expectObject(Terms.OBJECT_END,
StandardGrammars.DEFAULT_GRAMMAR_BLOCK);
}
expectProperty(Terms.LIST_PROPERTY_END,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT_CONTENT);
expectObject(Terms.OBJECT_END,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT);
expectEof();
}
/**
* A simple no doctype text
*/
public void testDoctype() {
startWithString("none", "doctype '"
+ StandardGrammars.DEFAULT_GRAMMAR_SYSTEM_ID
+ "' context 'DefaultContext';\n" + "a b c;");
// doctype statement
expectObject(Terms.OBJECT_START,
StandardGrammars.DOCTYPE_GRAMMAR_DOCTYPE);
expectValueProp(StandardGrammars.DOCTYPE_GRAMMAR_DOCTYPE_SYSTEM_ID, "'"
+ StandardGrammars.DEFAULT_GRAMMAR_SYSTEM_ID + "'");
expectValueProp(StandardGrammars.DOCTYPE_GRAMMAR_DOCTYPE_CONTEXT,
"'DefaultContext'");
expectObject(Terms.OBJECT_END, StandardGrammars.DOCTYPE_GRAMMAR_DOCTYPE);
// first statement
expectObject(Terms.OBJECT_START,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT);
expectProperty(Terms.LIST_PROPERTY_START,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT_CONTENT);
expectObject(Terms.OBJECT_START,
StandardGrammars.DEFAULT_GRAMMAR_TOKENS);
expectProperty(Terms.LIST_PROPERTY_START,
StandardGrammars.DEFAULT_GRAMMAR_TOKENS_VALUES);
expectValue("a");
expectValue("b");
expectValue("c");
expectProperty(Terms.LIST_PROPERTY_END,
StandardGrammars.DEFAULT_GRAMMAR_TOKENS_VALUES);
expectObject(Terms.OBJECT_END, StandardGrammars.DEFAULT_GRAMMAR_TOKENS);
expectProperty(Terms.LIST_PROPERTY_END,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT_CONTENT);
expectObject(Terms.OBJECT_END,
StandardGrammars.DEFAULT_GRAMMAR_STATEMENT);
// second statement
expectEof();
}
}